pax_global_header00006660000000000000000000000064151504562270014521gustar00rootroot0000000000000052 comment=9160b15aa6e60155f3ebb57966f8c4ffa27d5b84 golang-github-clipperhouse-uax29-2.7.0/000077500000000000000000000000001515045622700177245ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/.github/000077500000000000000000000000001515045622700212645ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/.github/workflows/000077500000000000000000000000001515045622700233215ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/.github/workflows/gofuzz.yml000066400000000000000000000012321515045622700253660ustar00rootroot00000000000000name: Fuzz on: push: branches: [ master ] pull_request: branches: [ master ] jobs: all: strategy: matrix: package: [words, sentences, graphemes, phrases] fuzzer: [FuzzValidShort, FuzzValidLong, FuzzInvalid] include: - package: graphemes fuzzer: FuzzANSIOptions runs-on: ubuntu-latest steps: - name: Set up Go uses: actions/setup-go@v6 - name: Check out code uses: actions/checkout@v6 - name: ${{ matrix.package }}.${{ matrix.fuzzer }} run: go test -fuzz=${{ matrix.fuzzer }} -fuzztime=60s github.com/clipperhouse/uax29/v2/${{ matrix.package }} golang-github-clipperhouse-uax29-2.7.0/.github/workflows/gotest.yml000066400000000000000000000007521515045622700253550ustar00rootroot00000000000000name: Test on: push: branches: [ master ] pull_request: branches: [ master ] jobs: all: runs-on: ubuntu-latest strategy: matrix: go-version: ['1.21', '1.22', '1.23', '1.24', '1.25', '1.26'] steps: - name: Check out code uses: actions/checkout@v6 - name: Set up Go uses: actions/setup-go@v6 with: go-version: ${{ matrix.go-version }} cache: true - name: Run test run: go test ./... -race -short golang-github-clipperhouse-uax29-2.7.0/.gitignore000066400000000000000000000000631515045622700217130ustar00rootroot00000000000000*.prof *.test temp/main.go .DS_Store .devcontainer/golang-github-clipperhouse-uax29-2.7.0/AGENTS.md000066400000000000000000000010701515045622700212250ustar00rootroot00000000000000This is a Go module containing several Go packages, which implement Unicode text segmentation UAX #29. The splitfunc.go files in each package are where the important logic lives. The required data is generated by the gen/ package. You will see that it downloads the property categories from the Unicode website, and generates the tries for each package. You will notice that most of the "get category" operations are done with bitwise operators, for performance. Always work incrementally. Do the smallest piece of work, test its correctness, and get my feedback. golang-github-clipperhouse-uax29-2.7.0/LICENSE000066400000000000000000000020551515045622700207330ustar00rootroot00000000000000MIT License Copyright (c) 2020 Matt Sherman Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. golang-github-clipperhouse-uax29-2.7.0/README.md000066400000000000000000000047071515045622700212130ustar00rootroot00000000000000This package tokenizes (splits) words, sentences and graphemes, based on [Unicode text segmentation](https://unicode.org/reports/tr29/) (UAX #29), for Unicode 17. Details and usage are in the respective packages: [uax29/graphemes](https://github.com/clipperhouse/uax29/tree/master/graphemes) [uax29/words](https://github.com/clipperhouse/uax29/tree/master/words) [uax29/phrases](https://github.com/clipperhouse/uax29/tree/master/phrases) [uax29/sentences](https://github.com/clipperhouse/uax29/tree/master/sentences) ### Why tokenize? Any time our code operates on individual words, we are tokenizing. Often, we do it ad hoc, such as splitting on spaces, which gives inconsistent results. The Unicode standard is better: it is multi-lingual, and handles punctuation, special characters, etc. ### Uses The uax29 module has 4 tokenizers. In decreasing granularity: sentences → phrases → words → graphemes. Words and graphemes are the most common uses. You might use `words` for inverted indexes, full-text search, TF-IDF, BM25, embeddings, etc. If you're doing embeddings, the definition of “meaningful unit” will depend on your application. You might choose sentences, phrases, words, or a combination. ### Conformance We use the official [Unicode test suites](https://unicode.org/reports/tr41/tr41-36.html#Tests29). Status: ![Go](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ## Quick start ``` go get "github.com/clipperhouse/uax29/v2/words" ``` ```go import "github.com/clipperhouse/uax29/v2/words" text := "Hello, 世界. Nice dog! 👍🐶" tokens := words.FromString(text) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current token } ``` ### See also [jargon](https://github.com/clipperhouse/jargon), a text pipelines package for CLI and Go, which consumes this package. ### Prior art [blevesearch/segment](https://github.com/blevesearch/segment) [rivo/uniseg](https://github.com/rivo/uniseg) ### Other language implementations [C#](https://github.com/clipperhouse/uax29.net) (also by me) [JavaScript](https://github.com/tc39/proposal-intl-segmenter) [Rust](https://unicode-rs.github.io/unicode-segmentation/unicode_segmentation/trait.UnicodeSegmentation.html) [Java](https://lucene.apache.org/core/6_5_0/core/org/apache/lucene/analysis/standard/StandardTokenizer.html) [Python](https://uniseg-python.readthedocs.io/en/latest/) golang-github-clipperhouse-uax29-2.7.0/doc.go000066400000000000000000000004201515045622700210140ustar00rootroot00000000000000// Package uax29 provides Unicode text segmentation (UAX #29) for words, sentences and graphemes. // // See the words, sentences, and graphemes packages for details and usage. // // For more information on the UAX #29 spec: https://unicode.org/reports/tr29/ package uax29 golang-github-clipperhouse-uax29-2.7.0/gen.go000066400000000000000000000000741515045622700210250ustar00rootroot00000000000000package uax29 //go:generate go run -C internal/gen main.go golang-github-clipperhouse-uax29-2.7.0/go.mod000066400000000000000000000003771515045622700210410ustar00rootroot00000000000000module github.com/clipperhouse/uax29/v2 go 1.18 // Surprising allocations in this release, do not use. retract v2.1.0 // This release was effectively identical to v2.0.1, and // only exists to revert the regression introduced in v2.1.0. retract v2.1.1 golang-github-clipperhouse-uax29-2.7.0/go.sum000066400000000000000000000000001515045622700210450ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/graphemes/000077500000000000000000000000001515045622700216775ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/graphemes/README.md000066400000000000000000000101661515045622700231620ustar00rootroot00000000000000An implementation of grapheme cluster boundaries from [Unicode text segmentation](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) (UAX 29), for Unicode 17. [![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/uax29/v2/graphemes.svg)](https://pkg.go.dev/github.com/clipperhouse/uax29/v2/graphemes) ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg) ## Quick start ``` go get github.com/clipperhouse/uax29/v2/graphemes ``` ```go import "github.com/clipperhouse/uax29/v2/graphemes" text := "Hello, 世界. Nice dog! 👍🐶" g := graphemes.FromString(text) for g.Next() { // Next() returns true until end of data fmt.Println(g.Value()) // Do something with the current grapheme } ``` _A grapheme is a “single visible character”, which might be a simple as a single letter, or a complex emoji that consists of several Unicode code points._ ## Conformance We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-36.html#Tests29). ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg) ## APIs ### If you have a `string` ```go text := "Hello, 世界. Nice dog! 👍🐶" g := graphemes.FromString(text) for g.Next() { // Next() returns true until end of data fmt.Println(g.Value()) // Do something with the current grapheme } ``` ### If you have an `io.Reader` `FromReader` embeds a [`bufio.Scanner`](https://pkg.go.dev/bufio#Scanner), so just use those methods. ```go r := getYourReader() // from a file or network maybe g := graphemes.FromReader(r) for g.Scan() { // Scan() returns true until error or EOF fmt.Println(g.Text()) // Do something with the current grapheme } if g.Err() != nil { // Check the error log.Fatal(g.Err()) } ``` ### If you have a `[]byte` ```go b := []byte("Hello, 世界. Nice dog! 👍🐶") g := graphemes.FromBytes(b) for g.Next() { // Next() returns true until end of data fmt.Println(g.Value()) // Do something with the current grapheme } ``` ### ANSI escape sequences By the UAX 29 specification, ANSI escape sequences are not grapheme clusters. To treat 7-bit ANSI escape sequences as a single cluster, set `AnsiEscapeSequences` to true. ```go text := "Hello, \x1b[31mworld\x1b[0m!" g := graphemes.FromString(text) g.AnsiEscapeSequences = true for g.Next() { fmt.Println(g.Value()) } ``` To also parse 8-bit C1 controls (non-UTF-8 bytes), set `AnsiEscapeSequences8Bit` to true. ```go g.AnsiEscapeSequences = true // 7-bit forms (ESC ...) g.AnsiEscapeSequences8Bit = true // 8-bit C1 forms (0x80-0x9F), not valid UTF-8 ``` For ESC-initiated (7-bit) control strings, only 7-bit terminators are recognized. For C1-initiated (8-bit) control strings, only C1 ST (`0x9C`) is recognized as ST. We implement [ECMA-48](https://ecma-international.org/publications-and-standards/standards/ecma-48/) control codes in both 7-bit and 8-bit representations. 8-bit control codes are not UTF-8 encoded and are not valid UTF-8, caveat emptor. ### Benchmarks ``` goos: darwin goarch: arm64 pkg: github.com/clipperhouse/uax29/graphemes/comparative cpu: Apple M2 BenchmarkGraphemesMixed/clipperhouse/uax29-8 142635 ns/op 245.12 MB/s 0 B/op 0 allocs/op BenchmarkGraphemesMixed/rivo/uniseg-8 2018284 ns/op 17.32 MB/s 0 B/op 0 allocs/op BenchmarkGraphemesASCII/clipperhouse/uax29-8 8846 ns/op 508.73 MB/s 0 B/op 0 allocs/op BenchmarkGraphemesASCII/rivo/uniseg-8 366760 ns/op 12.27 MB/s 0 B/op 0 allocs/op ``` ### Invalid inputs Invalid UTF-8 input is considered undefined behavior. We test to ensure that bad inputs will not cause pathological outcomes, such as a panic or infinite loop. Callers should expect “garbage-in, garbage-out”. Your pipeline should probably include a call to [`utf8.Valid()`](https://pkg.go.dev/unicode/utf8#Valid). golang-github-clipperhouse-uax29-2.7.0/graphemes/ansi.go000066400000000000000000000070551515045622700231670ustar00rootroot00000000000000package graphemes // ansiEscapeLength returns the byte length of a valid 7-bit ANSI escape // sequence at the start of data, or 0 if none. // // Recognized forms (ECMA-48 / ISO 6429): // - CSI: ESC [ then parameter bytes (0x30-0x3F), intermediate (0x20-0x2F), final (0x40-0x7E) // - OSC: ESC ] then payload until BEL (0x07), 7-bit ST (ESC \), CAN (0x18), or SUB (0x1A) // - DCS, SOS, PM, APC: ESC P/X/^/_ then payload until 7-bit ST (ESC \), CAN, or SUB // - Two-byte: ESC + Fe/Fs (0x40-0x7E excluding above), or Fp (0x30-0x3F), or nF (0x20-0x2F then final) func ansiEscapeLength[T ~string | ~[]byte](data T) int { n := len(data) if n < 2 || data[0] != esc { return 0 } b1 := data[1] switch b1 { case '[': // CSI body := csiBodyLength(data[2:]) if body == 0 { return 0 } return 2 + body case ']': // OSC - allows BEL or 7-bit ST terminator body := oscLength(data[2:]) if body < 0 { return 0 } return 2 + body case 'P', 'X', '^', '_': // DCS, SOS, PM, APC body := stSequenceLength(data[2:]) if body < 0 { return 0 } return 2 + body } if b1 >= 0x40 && b1 <= 0x7E { // Fe/Fs two-byte; [ ] P X ^ _ handled above return 2 } if b1 >= 0x30 && b1 <= 0x3F { // Fp (private) two-byte return 2 } if b1 >= 0x20 && b1 <= 0x2F { // nF: intermediates then one final (0x30-0x7E) i := 2 for i < n && data[i] >= 0x20 && data[i] <= 0x2F { i++ } if i < n && data[i] >= 0x30 && data[i] <= 0x7E { return i + 1 } return 0 } return 0 } // csiBodyLength returns the length of the CSI body (param/intermediate/final bytes). // data is the slice after "ESC [". // Per ECMA-48, the CSI body has the form: // // parameters (0x30–0x3F)*, intermediates (0x20–0x2F)*, final (0x40–0x7E) // // Once an intermediate byte is seen, subsequent parameter bytes are invalid. func csiBodyLength[T ~string | ~[]byte](data T) int { seenIntermediate := false for i := 0; i < len(data); i++ { b := data[i] if b >= 0x30 && b <= 0x3F { if seenIntermediate { return 0 } continue } if b >= 0x20 && b <= 0x2F { seenIntermediate = true continue } if b >= 0x40 && b <= 0x7E { return i + 1 } return 0 } return 0 } // oscLength returns the length of the OSC body. // data is the slice after "ESC ]". // // Returns: // - n >= 0: consumed body length (includes BEL/ST terminator when present) // - -1: not terminated in the provided data // // OSC accepts BEL (0x07) or 7-bit ST (ESC \) as terminators by widespread convention. // Per ECMA-48, CAN (0x18) and SUB (0x1A) cancel the control string; in that // case they are not part of the OSC sequence length. func oscLength[T ~string | ~[]byte](data T) int { for i := 0; i < len(data); i++ { b := data[i] if b == bel { return i + 1 } if b == can || b == sub { return i } if b == esc && i+1 < len(data) && data[i+1] == '\\' { return i + 2 } } return -1 } // stSequenceLength returns the length of a control-string body. // data is the slice after "ESC x". // // Returns: // - n >= 0: consumed body length (includes ST terminator when present) // - -1: not terminated in the provided data // // Used for DCS, SOS, PM, and APC, which per ECMA-48 terminate with ST. // ST here is the 7-bit form (ESC \). // CAN (0x18) and SUB (0x1A) cancel the control string; in that case they are // not part of the sequence length. func stSequenceLength[T ~string | ~[]byte](data T) int { for i := 0; i < len(data); i++ { if data[i] == can || data[i] == sub { return i } if data[i] == esc && i+1 < len(data) && data[i+1] == '\\' { return i + 2 } } return -1 } golang-github-clipperhouse-uax29-2.7.0/graphemes/ansi8.go000066400000000000000000000035601515045622700232540ustar00rootroot00000000000000package graphemes // ansiEscapeLength8Bit returns the byte length of a valid 8-bit C1 ANSI // sequence at the start of data, or 0 if none. // // Recognized forms (ECMA-48 / ISO 6429): // - C1 CSI (0x9B) body as parameter/intermediate/final bytes // - C1 OSC (0x9D) body terminated by BEL, C1 ST, CAN, or SUB // - C1 DCS/SOS/PM/APC (0x90/0x98/0x9E/0x9F) body terminated by C1 ST, CAN, or SUB // - Standalone C1 controls (0x80..0x9F not listed above): single byte func ansiEscapeLength8Bit[T ~string | ~[]byte](data T) int { if len(data) == 0 { return 0 } switch data[0] { case 0x9B: // C1 CSI body := csiBodyLength(data[1:]) if body == 0 { return 0 } return 1 + body case 0x9D: // C1 OSC body := oscLengthC1(data[1:]) if body < 0 { return 0 } return 1 + body case 0x90, 0x98, 0x9E, 0x9F: // C1 DCS, SOS, PM, APC body := stSequenceLengthC1(data[1:]) if body < 0 { return 0 } return 1 + body default: if data[0] >= 0x80 && data[0] <= 0x9F { return 1 } } return 0 } // oscLengthC1 returns the length of a C1 OSC body. // data is the slice after the C1 OSC initiator (0x9D). // // Returns: // - n >= 0: consumed body length (includes BEL/ST terminator when present) // - -1: not terminated in the provided data // // Terminators: BEL (0x07) or C1 ST (0x9C). // CAN (0x18) and SUB (0x1A) cancel the control string. func oscLengthC1[T ~string | ~[]byte](data T) int { for i := 0; i < len(data); i++ { b := data[i] if b == bel || b == st { return i + 1 } if b == can || b == sub { return i } } return -1 } // stSequenceLengthC1 parses DCS/SOS/PM/APC bodies that terminate with C1 ST // (0x9C), or are canceled by CAN/SUB. func stSequenceLengthC1[T ~string | ~[]byte](data T) int { for i := 0; i < len(data); i++ { b := data[i] if b == can || b == sub { return i } if b == st { return i + 1 } } return -1 } golang-github-clipperhouse-uax29-2.7.0/graphemes/ansi_test.go000066400000000000000000000473501515045622700242300ustar00rootroot00000000000000package graphemes_test import ( "reflect" "strings" "testing" "github.com/clipperhouse/uax29/v2/graphemes" "github.com/clipperhouse/uax29/v2/testdata" ) type ansiCase struct { name string input string expected []string } func assertANSITokens(t *testing.T, input string, expected []string, sevenBit, eightBit bool) { t.Helper() assertEqual := func(kind string, got []string) { t.Helper() if !reflect.DeepEqual(got, expected) { t.Errorf("%s mismatch\ngot %q\nexpected %q", kind, got, expected) } } iterString := graphemes.FromString(input) iterString.AnsiEscapeSequences = sevenBit iterString.AnsiEscapeSequences8Bit = eightBit var gotString []string for iterString.Next() { gotString = append(gotString, iterString.Value()) } assertEqual("string", gotString) iterBytes := graphemes.FromBytes([]byte(input)) iterBytes.AnsiEscapeSequences = sevenBit iterBytes.AnsiEscapeSequences8Bit = eightBit var gotBytes []string for iterBytes.Next() { gotBytes = append(gotBytes, string(iterBytes.Value())) } assertEqual("bytes", gotBytes) } func runANSICases(t *testing.T, tests []ansiCase, sevenBit, eightBit bool) { t.Helper() for _, tt := range tests { tt := tt t.Run(tt.name, func(t *testing.T) { t.Parallel() assertANSITokens(t, tt.input, tt.expected, sevenBit, eightBit) }) } } func TestAnsiEscapeSequences7BitOnlyAsGraphemes(t *testing.T) { t.Parallel() tests := []ansiCase{ {name: "SGR reset", input: "\x1b[0m", expected: []string{"\x1b[0m"}}, {name: "SGR red then text", input: "\x1b[31mhello", expected: []string{"\x1b[31m", "h", "e", "l", "l", "o"}}, {name: "CSI with valid intermediate", input: "\x1b[0 q", expected: []string{"\x1b[0 q"}}, {name: "OSC window title then BEL", input: "\x1b]0;My Title\x07", expected: []string{"\x1b]0;My Title\x07"}}, {name: "OSC window title then ST", input: "\x1b]0;Title\x1b\\", expected: []string{"\x1b]0;Title\x1b\\"}}, {name: "DCS with ST terminator", input: "\x1bPq#0;2;0;0;0\x1b\\", expected: []string{"\x1bPq#0;2;0;0;0\x1b\\"}}, {name: "DCS canceled by CAN", input: "\x1bPqdata\x18z", expected: []string{"\x1bPqdata", "\x18", "z"}}, {name: "SOS with ST terminator", input: "\x1bXhello\x1b\\", expected: []string{"\x1bXhello\x1b\\"}}, {name: "PM with ST terminator", input: "\x1b^msg\x1b\\", expected: []string{"\x1b^msg\x1b\\"}}, {name: "APC with ST terminator", input: "\x1b_data\x1b\\", expected: []string{"\x1b_data\x1b\\"}}, {name: "two-byte Fe", input: "\x1bD", expected: []string{"\x1bD"}}, {name: "two-byte Fp", input: "\x1b7", expected: []string{"\x1b7"}}, {name: "nF with multiple intermediates", input: "\x1b !Fx", expected: []string{"\x1b !F", "x"}}, {name: "malformed CSI remains split", input: "\x1b[ 1mok", expected: []string{"\x1b", "[", " ", "1", "m", "o", "k"}}, {name: "C1 CSI is not parsed", input: "\x9B31mhello", expected: []string{"\x9B", "3", "1", "m", "h", "e", "l", "l", "o"}}, {name: "7-bit OSC does not accept C1 ST", input: "\x1b]0;Title\x9Cz", expected: []string{"\x1b", "]", "0", ";", "T", "i", "t", "l", "e", "\x9C", "z"}}, } runANSICases(t, tests, true, false) } func TestAnsiEscapeSequences8BitOnlyAsGraphemes(t *testing.T) { t.Parallel() tests := []ansiCase{ {name: "C1 CSI then text", input: "\x9B31mhello", expected: []string{"\x9B31m", "h", "e", "l", "l", "o"}}, {name: "C1 CSI multiple params", input: "\x9B1;2;3m", expected: []string{"\x9B1;2;3m"}}, {name: "C1 OSC with C1 ST", input: "\x9D0;Title\x9C", expected: []string{"\x9D0;Title\x9C"}}, {name: "C1 OSC with 7-bit ST is not parsed as one sequence", input: "\x9D0;Title\x1b\\", expected: []string{"\x9D", "0", ";", "T", "i", "t", "l", "e", "\x1b", "\\"}}, {name: "C1 DCS with C1 ST", input: "\x90qpayload\x9C", expected: []string{"\x90qpayload\x9C"}}, {name: "C1 DCS with 7-bit ST is not parsed as one sequence", input: "\x90qpayload\x1b\\", expected: []string{"\x90", "q", "p", "a", "y", "l", "o", "a", "d", "\x1b", "\\"}}, {name: "C1 DCS canceled by CAN", input: "\x90qpayload\x18x", expected: []string{"\x90qpayload", "\x18", "x"}}, {name: "C1 SOS with C1 ST", input: "\x98hello\x9C", expected: []string{"\x98hello\x9C"}}, {name: "C1 PM with 7-bit ST is not parsed as one sequence", input: "\x9Emsg\x1b\\", expected: []string{"\x9E", "m", "s", "g", "\x1b", "\\"}}, {name: "C1 APC with C1 ST", input: "\x9Fdata\x9C", expected: []string{"\x9Fdata\x9C"}}, {name: "single C1 Fe control", input: "\x84", expected: []string{"\x84"}}, {name: "C1 OSC unterminated", input: "\x9D0;title", expected: []string{"\x9D", "0", ";", "t", "i", "t", "l", "e"}}, {name: "C1 DCS unterminated", input: "\x90data", expected: []string{"\x90", "d", "a", "t", "a"}}, {name: "7-bit ESC sequence is not parsed", input: "\x1b[31mhello", expected: []string{"\x1b", "[", "3", "1", "m", "h", "e", "l", "l", "o"}}, } runANSICases(t, tests, false, true) } func TestAnsiEscapeSequencesBothEnabledAsGraphemes(t *testing.T) { t.Parallel() tests := []ansiCase{ { name: "SGR reset", input: "\x1b[0m", expected: []string{"\x1b[0m"}, }, { name: "SGR red then text", input: "\x1b[31mhello", expected: []string{"\x1b[31m", "h", "e", "l", "l", "o"}, }, { name: "CSI with params and final", input: "\x1b[1;32m", expected: []string{"\x1b[1;32m"}, }, { name: "OSC window title then BEL", input: "\x1b]0;My Title\x07", expected: []string{"\x1b]0;My Title\x07"}, }, { name: "OSC UTF-8 payload does not terminate at continuation byte", input: "\x1b]0;本\x07", expected: []string{"\x1b]0;本\x07"}, }, { name: "OSC window title then ST", input: "\x1b]0;Title\x1b\\", expected: []string{"\x1b]0;Title\x1b\\"}, }, { name: "DCS with ST terminator", input: "\x1bPq#0;2;0;0;0\x1b\\", expected: []string{"\x1bPq#0;2;0;0;0\x1b\\"}, }, { name: "DCS UTF-8 payload does not terminate at continuation byte", input: "\x1bPq本\x1b\\", expected: []string{"\x1bPq本\x1b\\"}, }, { name: "DCS with BEL in payload is not a single sequence", input: "\x1bPq\x07rest", expected: []string{"\x1b", "P", "q", "\x07", "r", "e", "s", "t"}, }, { name: "DCS canceled by CAN", input: "\x1bPqdata\x18z", expected: []string{"\x1bPqdata", "\x18", "z"}, }, { name: "DCS canceled immediately by CAN", input: "\x1bP\x18z", expected: []string{"\x1bP", "\x18", "z"}, }, { name: "DCS canceled by SUB", input: "\x1bPqdata\x1az", expected: []string{"\x1bPqdata", "\x1a", "z"}, }, { name: "SOS with ST terminator", input: "\x1bXhello\x1b\\", expected: []string{"\x1bXhello\x1b\\"}, }, { name: "SOS with BEL in payload is not a single sequence", input: "\x1bXhi\x07", expected: []string{"\x1b", "X", "h", "i", "\x07"}, }, { name: "PM with ST terminator", input: "\x1b^msg\x1b\\", expected: []string{"\x1b^msg\x1b\\"}, }, { name: "PM with BEL in payload is not a single sequence", input: "\x1b^m\x07", expected: []string{"\x1b", "^", "m", "\x07"}, }, { name: "APC with ST terminator", input: "\x1b_data\x1b\\", expected: []string{"\x1b_data\x1b\\"}, }, { name: "APC with BEL in payload is not a single sequence", input: "\x1b_d\x07", expected: []string{"\x1b", "_", "d", "\x07"}, }, { name: "OSC empty payload with BEL", input: "\x1b]\x07", expected: []string{"\x1b]\x07"}, }, { name: "DCS unterminated", input: "\x1bPdata", expected: []string{"\x1b", "P", "d", "a", "t", "a"}, }, { name: "OSC unterminated", input: "\x1b]0;title", expected: []string{"\x1b", "]", "0", ";", "t", "i", "t", "l", "e"}, }, { name: "OSC canceled by CAN", input: "\x1b]0;title\x18x", expected: []string{"\x1b]0;title", "\x18", "x"}, }, { name: "OSC canceled by SUB", input: "\x1b]0;title\x1ax", expected: []string{"\x1b]0;title", "\x1a", "x"}, }, { name: "two-byte Fe", input: "\x1bD", // IND expected: []string{"\x1bD"}, }, { name: "two-byte Fs RIS", input: "\x1bc", expected: []string{"\x1bc"}, }, { name: "two-byte Fs upper boundary 0x7E", input: "\x1b~x", expected: []string{"\x1b~", "x"}, }, { name: "ESC DEL (0x7F) is not Fs", input: "\x1b\x7f", expected: []string{"\x1b", "\x7f"}, }, { name: "two-byte Fp DECSC", input: "\x1b7", expected: []string{"\x1b7"}, }, { name: "nF ESC SP F", input: "\x1b F", expected: []string{"\x1b F"}, }, { name: "mixed: CSI then letter", input: "\x1b[mx", expected: []string{"\x1b[m", "x"}, }, { name: "C1 CSI then text", input: "\x9B31mhello", expected: []string{"\x9B31m", "h", "e", "l", "l", "o"}, }, { name: "C1 OSC with C1 ST terminator", input: "\x9D0;Title\x9C", expected: []string{"\x9D0;Title\x9C"}, }, { name: "C1 OSC with 7-bit ST terminator", input: "\x9D0;Title\x1b\\", expected: []string{"\x9D", "0", ";", "T", "i", "t", "l", "e", "\x1b\\"}, }, { name: "7-bit OSC with C1 ST terminator", input: "\x1b]0;Title\x9C", expected: []string{"\x1b", "]", "0", ";", "T", "i", "t", "l", "e", "\x9C"}, }, { name: "C1 DCS with C1 ST terminator", input: "\x90qpayload\x9C", expected: []string{"\x90qpayload\x9C"}, }, { name: "C1 DCS canceled by CAN", input: "\x90qpayload\x18x", expected: []string{"\x90qpayload", "\x18", "x"}, }, { name: "C1 DCS with 7-bit ST terminator", input: "\x90qpayload\x1b\\", expected: []string{"\x90", "q", "p", "a", "y", "l", "o", "a", "d", "\x1b\\"}, }, { name: "7-bit DCS with C1 ST terminator", input: "\x1bPqpayload\x9C", expected: []string{"\x1b", "P", "q", "p", "a", "y", "l", "o", "a", "d", "\x9C"}, }, { name: "C1 Fe IND control", input: "\x84", expected: []string{"\x84"}, }, { name: "nF malformed: no final byte", input: "\x1b \x1b", expected: []string{"\x1b", " ", "\x1b"}, }, { name: "nF with multiple intermediates", input: "\x1b !Fx", expected: []string{"\x1b !F", "x"}, }, { name: "nF with private-use final (0x30)", input: "\x1b 0", expected: []string{"\x1b 0"}, }, { name: "CSI with valid intermediate byte", input: "\x1b[0 q", expected: []string{"\x1b[0 q"}, }, { name: "C1 OSC unterminated", input: "\x9D0;title", expected: []string{"\x9D", "0", ";", "t", "i", "t", "l", "e"}, }, { name: "C1 DCS unterminated", input: "\x90data", expected: []string{"\x90", "d", "a", "t", "a"}, }, { name: "C1 SOS with C1 ST terminator", input: "\x98hello\x9C", expected: []string{"\x98hello\x9C"}, }, { name: "C1 PM with 7-bit ST terminator", input: "\x9Emsg\x1b\\", expected: []string{"\x9E", "m", "s", "g", "\x1b\\"}, }, { name: "C1 APC with C1 ST terminator", input: "\x9Fdata\x9C", expected: []string{"\x9Fdata\x9C"}, }, { name: "single ESC byte", input: "\x1b", expected: []string{"\x1b"}, }, { name: "single C1 control byte", input: "\x84", expected: []string{"\x84"}, }, { name: "UTF-8 cafe", input: "café", expected: []string{"c", "a", "f", "é"}, }, { name: "UTF-8 Japanese text", input: "日本語", expected: []string{"日", "本", "語"}, }, { name: "UTF-8 runes with continuation bytes in C1 range", input: "Āğל", expected: []string{"Ā", "ğ", "ל"}, }, { name: "mixed ANSI and UTF-8 adversarial payload", input: "\x1b[31mĀğ日本語café\x1b[0m", expected: []string{"\x1b[31m", "Ā", "ğ", "日", "本", "語", "c", "a", "f", "é", "\x1b[0m"}, }, { name: "SOS canceled by CAN", input: "\x1bXhello\x18z", expected: []string{"\x1bXhello", "\x18", "z"}, }, { name: "malformed CSI: param after intermediate", input: "\x1b[ 1mok", expected: []string{"\x1b", "[", " ", "1", "m", "o", "k"}, }, { name: "no ANSI at start", input: "plain", expected: []string{"p", "l", "a", "i", "n"}, }, } runANSICases(t, tests, true, true) } func TestAnsiEscapeSequencesPureUTF8Parity(t *testing.T) { t.Parallel() samples := []string{ "café", "日本語", "Āğל", "A\u0301", "👩🏽‍💻", "Résumé — 東京 — 👍", } collectString := func(input string, ansi7, ansi8 bool) []string { iter := graphemes.FromString(input) iter.AnsiEscapeSequences = ansi7 iter.AnsiEscapeSequences8Bit = ansi8 var out []string for iter.Next() { out = append(out, iter.Value()) } return out } collectBytes := func(input string, ansi7, ansi8 bool) []string { iter := graphemes.FromBytes([]byte(input)) iter.AnsiEscapeSequences = ansi7 iter.AnsiEscapeSequences8Bit = ansi8 var out []string for iter.Next() { out = append(out, string(iter.Value())) } return out } for i, sample := range samples { sample := sample t.Run("sample-"+string(rune('A'+i)), func(t *testing.T) { t.Parallel() stringBase := collectString(sample, false, false) for _, flags := range []struct { name string ansi7 bool ansi8 bool }{ {name: "7-bit only", ansi7: true, ansi8: false}, {name: "8-bit only", ansi7: false, ansi8: true}, {name: "both", ansi7: true, ansi8: true}, } { gotString := collectString(sample, flags.ansi7, flags.ansi8) if !reflect.DeepEqual(stringBase, gotString) { t.Fatalf("string parity mismatch for %q (%s)\noff=%q\non=%q", sample, flags.name, stringBase, gotString) } bytesBase := collectBytes(sample, false, false) gotBytes := collectBytes(sample, flags.ansi7, flags.ansi8) if !reflect.DeepEqual(bytesBase, gotBytes) { t.Fatalf("bytes parity mismatch for %q (%s)\noff=%q\non=%q", sample, flags.name, bytesBase, gotBytes) } } }) } } // ansiSample builds a string that mixes ANSI escape sequences with regular text, // simulating realistic terminal output (colored words, resets, bold, etc.). func ansiSample() string { var b strings.Builder // Simulate `ls --color=auto`-style output: colored filenames with resets colors := []string{ "\x1b[1;34m", // bold blue (directories) "\x1b[0;32m", // green (executables) "\x1b[0;36m", // cyan (symlinks) "\x1b[1;31m", // bold red (errors) "\x1b[33m", // yellow (warnings) } reset := "\x1b[0m" lines := []string{ "drwxr-xr-x 5 user staff 160 Jan 1 12:00 Documents", "drwxr-xr-x 3 user staff 96 Feb 2 09:30 Downloads", "-rwxr-xr-x 1 user staff 8432 Mar 15 14:22 build.sh", "lrwxr-xr-x 1 user staff 11 Apr 20 08:00 config -> /etc/config", "-rw-r--r-- 1 user staff 1024 May 5 16:45 README.md", "total 42", "drwxr-xr-x 2 user staff 64 Jun 10 11:11 src", "-rw-r--r-- 1 user staff 512 Jul 7 07:07 main.go", "error: file not found: missing.txt", "warning: deprecated function used in line 42", } // Repeat to get a decent-sized sample for round := 0; round < 20; round++ { for i, line := range lines { color := colors[i%len(colors)] // OSC title update every 5 lines if i%5 == 0 { b.WriteString("\x1b]0;terminal - round ") b.WriteString(string(rune('0' + round%10))) b.WriteString("\x07") } b.WriteString(color) b.WriteString(line) b.WriteString(reset) b.WriteString("\n") } } return b.String() } // ansiSample8Bit builds a string that uses 8-bit C1 initiators. func ansiSample8Bit() string { var b strings.Builder lines := []string{ "drwxr-xr-x 5 user staff 160 Jan 1 12:00 Documents", "drwxr-xr-x 3 user staff 96 Feb 2 09:30 Downloads", "-rwxr-xr-x 1 user staff 8432 Mar 15 14:22 build.sh", "lrwxr-xr-x 1 user staff 11 Apr 20 08:00 config -> /etc/config", "-rw-r--r-- 1 user staff 1024 May 5 16:45 README.md", "total 42", "drwxr-xr-x 2 user staff 64 Jun 10 11:11 src", "-rw-r--r-- 1 user staff 512 Jul 7 07:07 main.go", "error: file not found: missing.txt", "warning: deprecated function used in line 42", } for round := 0; round < 20; round++ { for i, line := range lines { // C1 OSC: 0x9D ... BEL if i%5 == 0 { b.WriteByte(0x9D) b.WriteString("0;terminal - round ") b.WriteString(string(rune('0' + round%10))) b.WriteByte(0x07) } // C1 CSI SGR: 0x9B ... m b.WriteByte(0x9B) b.WriteString("1;3") b.WriteString(string(rune('0' + (i % 8)))) b.WriteByte('m') b.WriteString(line) // C1 CSI reset: 0x9B0m b.WriteByte(0x9B) b.WriteString("0m") b.WriteByte('\n') } } return b.String() } // ansiSampleMixed builds a string with both 7-bit and 8-bit ANSI forms. func ansiSampleMixed() string { var b strings.Builder a7 := ansiSample() a8 := ansiSample8Bit() b.WriteString(a7) b.WriteString(a8) return b.String() } // BenchmarkAnsiOption benchmarks the iterator on text that contains ANSI escapes, // and on plain text, with the AnsiEscapeSequences option on and off. func BenchmarkAnsiOption(b *testing.B) { ansi7 := ansiSample() ansi8 := ansiSample8Bit() ansiMixed := ansiSampleMixed() plain, err := testdata.Sample() if err != nil { b.Fatal(err) } plainStr := string(plain) b.Run("AnsiText7Bit/Option7BitOn", func(b *testing.B) { b.SetBytes(int64(len(ansi7))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(ansi7) iter.AnsiEscapeSequences = true c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) b.Run("AnsiText7Bit/OptionOff", func(b *testing.B) { b.SetBytes(int64(len(ansi7))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(ansi7) c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) b.Run("AnsiText8Bit/Option8BitOn", func(b *testing.B) { b.SetBytes(int64(len(ansi8))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(ansi8) iter.AnsiEscapeSequences8Bit = true c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) b.Run("AnsiText8Bit/OptionOff", func(b *testing.B) { b.SetBytes(int64(len(ansi8))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(ansi8) c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) b.Run("AnsiTextMixed/BothOptionsOn", func(b *testing.B) { b.SetBytes(int64(len(ansiMixed))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(ansiMixed) iter.AnsiEscapeSequences = true iter.AnsiEscapeSequences8Bit = true c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) b.Run("PlainText/Option7BitOn", func(b *testing.B) { b.SetBytes(int64(len(plainStr))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(plainStr) iter.AnsiEscapeSequences = true c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) b.Run("PlainText/Option8BitOn", func(b *testing.B) { b.SetBytes(int64(len(plainStr))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(plainStr) iter.AnsiEscapeSequences8Bit = true c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) b.Run("PlainText/BothOptionsOn", func(b *testing.B) { b.SetBytes(int64(len(plainStr))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(plainStr) iter.AnsiEscapeSequences = true iter.AnsiEscapeSequences8Bit = true c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) b.Run("PlainText/OptionOff", func(b *testing.B) { b.SetBytes(int64(len(plainStr))) for i := 0; i < b.N; i++ { iter := graphemes.FromString(plainStr) c := 0 for iter.Next() { _ = iter.Value() c++ } b.ReportMetric(float64(c), "tokens") } }) } golang-github-clipperhouse-uax29-2.7.0/graphemes/bytes_test.go000066400000000000000000000051311515045622700244130ustar00rootroot00000000000000package graphemes_test import ( "bytes" "reflect" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/graphemes" "github.com/clipperhouse/uax29/v2/testdata" ) func TestBytesUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { test := test var all [][]byte tokens := graphemes.FromBytes(test.input) for tokens.Next() { all = append(all, tokens.Value()) } if !reflect.DeepEqual(all, test.expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, all, test.comment) } else { passed++ } } if len(unicodeTests) != passed+failed { t.Errorf("Incomplete %d tests: passed %d, failed %d", len(unicodeTests), passed, failed) } } // TestBytesRoundtrip tests that all input bytes are output by the iterator. func TestBytesRoundtrip(t *testing.T) { t.Parallel() const runs = 100 tokens := graphemes.FromBytes(nil) for i := 0; i < runs; i++ { input := getRandomBytes() tokens.SetText(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatal("input bytes are not the same as output bytes") } } } func TestBytesInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } tokens := graphemes.FromBytes(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as output bytes") } } func BenchmarkBytes(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := graphemes.FromBytes(file) c := 0 for tokens.Next() { _ = tokens.Value() c++ } b.ReportMetric(float64(c), "tokens") } } func BenchmarkBytesUnicodeTests(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := graphemes.FromBytes(file) c := 0 for tokens.Next() { _ = tokens.Value() c++ } b.ReportMetric(float64(c), "tokens") } } golang-github-clipperhouse-uax29-2.7.0/graphemes/comparative/000077500000000000000000000000001515045622700242115ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/graphemes/comparative/comparative_test.go000066400000000000000000000245751515045622700301260ustar00rootroot00000000000000package comparative import ( "reflect" "strings" "testing" "github.com/charmbracelet/x/ansi" "github.com/clipperhouse/uax29/v2/graphemes" "github.com/clipperhouse/uax29/v2/testdata" "github.com/rivo/uniseg" ) func BenchmarkGraphemesMixed(b *testing.B) { data, err := testdata.Sample() if err != nil { b.Fatal(err) } text := string(data) n := int64(len(text)) b.Run("clipperhouse/uax29", func(b *testing.B) { b.SetBytes(n) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { count := 0 g := graphemes.FromString(text) for g.Next() { count++ } } }) b.Run("rivo/uniseg", func(b *testing.B) { b.SetBytes(n) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { count := 0 g := uniseg.NewGraphemes(text) for g.Next() { count++ } } }) } func BenchmarkGraphemesASCII(b *testing.B) { // Pure ASCII text - should benefit from ASCII hot path ascii := strings.Repeat("The quick brown fox jumps over the lazy dog. ", 100) n := int64(len(ascii)) b.Run("clipperhouse/uax29", func(b *testing.B) { b.SetBytes(n) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { count := 0 g := graphemes.FromString(ascii) for g.Next() { count++ } } }) b.Run("rivo/uniseg", func(b *testing.B) { b.SetBytes(n) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { count := 0 g := uniseg.NewGraphemes(ascii) for g.Next() { count++ } } }) } // TestAnsiBoundaryAgreement verifies that our ANSI sequence parsing produces // the same token boundaries as charmbracelet/x/ansi's DecodeSequence. // Inputs use ASCII text between sequences so grapheme clustering differences // don't obscure ANSI boundary comparison. func TestAnsiBoundaryAgreement(t *testing.T) { tests := []struct { name string input string }{ // 7-bit CSI {"SGR reset", "\x1b[0m"}, {"SGR color then text then reset", "\x1b[31mhello\x1b[0m"}, {"CSI bold+color", "\x1b[1;32m"}, {"CSI cursor position", "\x1b[10;20H"}, // 7-bit OSC {"OSC title with BEL", "\x1b]0;My Title\x07"}, {"OSC title with ST", "\x1b]0;Title\x1b\\"}, // 7-bit DCS/SOS/PM/APC {"DCS with ST", "\x1bPq#0;2;0;0;0\x1b\\"}, {"SOS with ST", "\x1bXhello\x1b\\"}, {"PM with ST", "\x1b^msg\x1b\\"}, {"APC with ST", "\x1b_data\x1b\\"}, // Two-byte Fe/Fs/Fp {"Fe IND", "\x1bD"}, {"Fs RIS", "\x1bc"}, {"Fp DECSC", "\x1b7"}, // C1 8-bit {"C1 CSI then text", "\x9B31mhello"}, {"C1 OSC with C1 ST", "\x9D0;Title\x9C"}, {"C1 DCS with C1 ST", "\x90qpayload\x9C"}, {"C1 SOS with C1 ST", "\x98hello\x9C"}, {"C1 APC with C1 ST", "\x9Fdata\x9C"}, // CSI variants (from charmbracelet test suite) {"CSI private mode", "\x1b[?1049h"}, {"CSI subparams (colons)", "\x1b[38:2:255:0:255;1m"}, {"CSI with intermediate", "\x1b[0 q"}, {"CSI no params", "\x1b[m"}, {"CSI mouse click", "\x1b[<0;1;1M"}, {"CSI mouse wheel", "\x1b[<64;2;11m"}, {"CSI bracketed paste on", "\x1b[?2004h"}, {"CSI bracketed paste content", "\x1b[200~pasted text\x1b[201~"}, // SS3 / SS2 (Single Shift) {"SS3 7-bit", "\x1bOA"}, {"SS3 8-bit", "\x8fA"}, {"SS2 7-bit", "\x1bNA"}, {"SS2 8-bit", "\x8eA"}, // nF sequences {"nF charset G0", "\x1b(A"}, {"nF charset G0 then text", "\x1b(Btext"}, // DCS with params {"C1 DCS with params and C1 ST", "\x90?123;456+q\x9c"}, // APC payload (Kitty graphics protocol) {"APC kitty graphics", "\x1b_Gf=24,s=10,v=20,o=z;aGVsbG8gd29ybGQ=\x1b\\"}, // C1 CSI with multiple params {"C1 CSI multiple params", "\x9B1;2;3m"}, // Mixed 7-bit and C1 {"mixed 7-bit and C1", "\x1b[1m\x9B31mhello\x1b[0m"}, // Concatenated sequences {"concatenated CSI+OSC", "\x1b[1;2;3m\x1b]2;Terminal\x07"}, {"OSC then CSI", "\x1b]0;Title\x07\x1b[31mred\x1b[0m"}, // Text around sequences {"text around SGR", "hello, \x1b[1;2;3mworld\x1b[0m!"}, // Realistic colored output {"colored ls", "\x1b[1;34mDocuments\x1b[0m \x1b[0;32mbuild.sh\x1b[0m"}, // Plain text (no ANSI) {"plain ASCII", "hello world"}, // DecodeSequence parser parity edge cases {"single ESC byte", "\x1b"}, {"single NUL byte", "\x00"}, {"ASCII DEL byte", "\x7f"}, {"DEL between ASCII runes", "a\x7fb"}, {"double ESC", "\x1b\x1b"}, {"double ST 7-bit", "\x1b\\\x1b\\"}, {"double ST 8-bit", "\x9c\x9c"}, {"single-param OSC", "\x1b]112\x07"}, {"ESC with intermediate", "\x1b Q"}, {"DCS containing DEL payload", "\x1bP1;2+xa\x7fb\x1b\\"}, {"OSC with C1 bytes in payload", "\x1b]11;\x90?\x1b\\"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { ours := uax29Tokens(tt.input) theirs := charmTokens(tt.input) if !reflect.DeepEqual(ours, theirs) { t.Errorf("boundary mismatch\nours: %q\ntheirs: %q", ours, theirs) } }) } } // TestAnsiBoundaryKnownDivergences documents cases where our grapheme-oriented // tokenizer intentionally differs from charmbracelet/x/ansi DecodeSequence. func TestAnsiBoundaryKnownDivergences(t *testing.T) { tests := []struct { name string input string reason string }{ { name: "unterminated CSI", input: "\x1b[1;2;3", reason: "DecodeSequence returns one unterminated CSI token; we split when no final byte is present", }, { name: "unterminated OSC", input: "\x1b]11;ff/00/ff", reason: "DecodeSequence returns one unterminated OSC token; we split when OSC has no BEL/ST/CAN/SUB terminator", }, { name: "unterminated OSC followed by CSI", input: "\x1b]11;ff/00/ff\x1b[1;2;3m", reason: "DecodeSequence ends OSC at ESC and parses following CSI; we require explicit OSC terminator", }, { name: "unterminated OSC followed by bare ESC", input: "\x1b]11;ff/00/ff\x1b", reason: "DecodeSequence emits unterminated OSC then ESC; we split because OSC is invalid without terminator", }, { name: "unterminated DCS", input: "\x1bP1;2+xa", reason: "DecodeSequence returns one unterminated DCS token; we split when DCS has no ST/CAN/SUB terminator", }, { name: "invalid DCS immediately terminated", input: "\x1bP\x1b\\ab", reason: "DecodeSequence emits ESC P token before ST; we do not treat invalid DCS start as a sequence", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { ours := uax29Tokens(tt.input) theirs := charmTokens(tt.input) if reflect.DeepEqual(ours, theirs) { t.Fatalf("expected divergence, but boundaries matched\nreason: %s\ntokens: %q", tt.reason, ours) } t.Logf("reason: %s", tt.reason) t.Logf("ours: %q", ours) t.Logf("theirs: %q", theirs) }) } } // ansiSample builds a realistic ANSI-heavy string simulating colored terminal output. func ansiSample() string { var b strings.Builder colors := []string{ "\x1b[1;34m", // bold blue "\x1b[0;32m", // green "\x1b[0;36m", // cyan "\x1b[1;31m", // bold red "\x1b[33m", // yellow } reset := "\x1b[0m" lines := []string{ "drwxr-xr-x 5 user staff 160 Jan 1 12:00 Documents", "drwxr-xr-x 3 user staff 96 Feb 2 09:30 Downloads", "-rwxr-xr-x 1 user staff 8432 Mar 15 14:22 build.sh", "lrwxr-xr-x 1 user staff 11 Apr 20 08:00 config", "-rw-r--r-- 1 user staff 1024 May 5 16:45 README.md", } for round := 0; round < 40; round++ { for i, line := range lines { color := colors[i%len(colors)] if i%5 == 0 { b.WriteString("\x1b]0;terminal - round ") b.WriteString(string(rune('0' + round%10))) b.WriteString("\x07") } b.WriteString(color) b.WriteString(line) b.WriteString(reset) b.WriteString("\n") } } return b.String() } func ansiSample8Bit() string { var b strings.Builder lines := []string{ "drwxr-xr-x 5 user staff 160 Jan 1 12:00 Documents", "drwxr-xr-x 3 user staff 96 Feb 2 09:30 Downloads", "-rwxr-xr-x 1 user staff 8432 Mar 15 14:22 build.sh", "lrwxr-xr-x 1 user staff 11 Apr 20 08:00 config", "-rw-r--r-- 1 user staff 1024 May 5 16:45 README.md", } for round := 0; round < 40; round++ { for i, line := range lines { if i%5 == 0 { b.WriteByte(0x9D) b.WriteString("0;terminal - round ") b.WriteString(string(rune('0' + round%10))) b.WriteByte(0x07) } b.WriteByte(0x9B) b.WriteString("1;3") b.WriteString(string(rune('0' + (i % 8)))) b.WriteByte('m') b.WriteString(line) b.WriteByte(0x9B) b.WriteString("0m") b.WriteString("\n") } } return b.String() } func ansiSampleMixed() string { return ansiSample() + ansiSample8Bit() } func BenchmarkAnsiIteration(b *testing.B) { input7 := ansiSample() input8 := ansiSample8Bit() inputMixed := ansiSampleMixed() b.Run("clipperhouse/uax29/7bit", func(b *testing.B) { b.SetBytes(int64(len(input7))) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { count := 0 g := graphemes.FromString(input7) g.AnsiEscapeSequences = true for g.Next() { count++ } } }) b.Run("clipperhouse/uax29/8bit", func(b *testing.B) { b.SetBytes(int64(len(input8))) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { count := 0 g := graphemes.FromString(input8) g.AnsiEscapeSequences8Bit = true for g.Next() { count++ } } }) b.Run("clipperhouse/uax29/both", func(b *testing.B) { b.SetBytes(int64(len(inputMixed))) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { count := 0 g := graphemes.FromString(inputMixed) g.AnsiEscapeSequences = true g.AnsiEscapeSequences8Bit = true for g.Next() { count++ } } }) b.Run("charmbracelet/x/ansi/mixed", func(b *testing.B) { b.SetBytes(int64(len(inputMixed))) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { count := 0 var state byte remaining := inputMixed for len(remaining) > 0 { _, _, advance, newState := ansi.DecodeSequence(remaining, state, nil) state = newState remaining = remaining[advance:] count++ } } }) } // uax29Tokens segments the input using our graphemes iterator with ANSI support. func uax29Tokens(input string) []string { iter := graphemes.FromString(input) iter.AnsiEscapeSequences = true iter.AnsiEscapeSequences8Bit = true var tokens []string for iter.Next() { tokens = append(tokens, iter.Value()) } return tokens } // charmTokens segments the input using charmbracelet/x/ansi's DecodeSequence. func charmTokens(input string) []string { var state byte remaining := input var tokens []string for len(remaining) > 0 { seq, _, n, newState := ansi.DecodeSequence(remaining, state, nil) tokens = append(tokens, seq) state = newState remaining = remaining[n:] } return tokens } golang-github-clipperhouse-uax29-2.7.0/graphemes/comparative/go.mod000066400000000000000000000007361515045622700253250ustar00rootroot00000000000000module github.com/clipperhouse/uax29/graphemes/comparative go 1.24.2 require ( github.com/charmbracelet/x/ansi v0.11.6 github.com/clipperhouse/uax29/v2 v2.6.0 github.com/rivo/uniseg v0.4.7 ) require ( github.com/clipperhouse/displaywidth v0.9.0 // indirect github.com/clipperhouse/stringish v0.1.1 // indirect github.com/lucasb-eyer/go-colorful v1.3.0 // indirect github.com/mattn/go-runewidth v0.0.19 // indirect ) replace github.com/clipperhouse/uax29/v2 => ../../ golang-github-clipperhouse-uax29-2.7.0/graphemes/comparative/go.sum000066400000000000000000000021001515045622700253350ustar00rootroot00000000000000github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8= github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ= github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA= github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA= github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs= github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA= github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag= github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw= github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs= github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= golang-github-clipperhouse-uax29-2.7.0/graphemes/fuzz_test.go000066400000000000000000000132421515045622700242650ustar00rootroot00000000000000package graphemes_test import ( "bytes" mathrand "math/rand" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/graphemes" "github.com/clipperhouse/uax29/v2/testdata" ) // FuzzValidShort fuzzes small, valid UTF8 strings. I suspect more, shorter // strings in the corpus lead to more mutation and coverage. True? func FuzzValidShort(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } // unicode test suite for _, test := range unicodeTests { f.Add(test.input) } // multi-lingual text, as small-ish lines file, err := testdata.Sample() if err != nil { f.Error(err) } lines := bytes.Split(file, []byte("\n")) for _, line := range lines { f.Add(line) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := graphemes.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzValidLong fuzzes longer, valid UTF8 strings. func FuzzValidLong(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } // add multi-lingual text, as decent (paragraph-sized) size chunks file, err := testdata.Sample() if err != nil { f.Error(err) } chunks := bytes.Split(file, []byte("\n\n\n")) for _, chunk := range chunks { f.Add(chunk) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := graphemes.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzInvalid fuzzes invalid UTF8 strings. func FuzzInvalid(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } random := getRandomBytes() const max = 100 const min = 1 pos := 0 for { // random smaller strings ln := mathrand.Intn(max-min) + min if pos+ln > len(random) { break } f.Add(random[pos : pos+ln]) pos += ln } // known invalid utf-8 badUTF8, err := testdata.InvalidUTF8() if err != nil { f.Error(err) } lines := bytes.Split(badUTF8, []byte("\n")) for _, line := range lines { f.Add(line) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := graphemes.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzANSIOptions fuzzes iterator roundtripping with ANSI options enabled. // This specifically exercises 7-bit only, 8-bit only, and combined modes. func FuzzANSIOptions(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } seeds := [][]byte{ []byte("\x1b[31mhello\x1b[0m"), // 7-bit CSI []byte("\x1b]0;Title\x07"), // 7-bit OSC + BEL []byte("\x1bPqpayload\x1b\\"), // 7-bit DCS + 7-bit ST []byte("\x9B31mhello"), // C1 CSI []byte("\x9D0;Title\x9C"), // C1 OSC + C1 ST []byte("\x90qpayload\x9C"), // C1 DCS + C1 ST []byte("\x98hello\x9C"), // C1 SOS + C1 ST []byte("\x9Emsg\x9C"), // C1 PM + C1 ST []byte("\x9Fdata\x9C"), // C1 APC + C1 ST []byte("\x1b]0;Title\x9C"), // 7-bit initiator + C1 ST (strict negative) []byte("\x9D0;Title\x1b\\"), // C1 initiator + 7-bit ST (strict negative) []byte("\x1b]0;本\x07"), // UTF-8 in OSC payload []byte("\x90q本\x9C"), // UTF-8 in C1 DCS payload []byte("\x1b[31m\x9B1;32mtext\x1b[0m"), // mixed 7-bit + 8-bit CSI []byte("\x1b"), // truncated ESC []byte("\x9D0;unterminated"), // unterminated C1 OSC []byte("plain UTF-8: café 日本語 👩🏽‍💻"), // non-ANSI UTF-8 } for _, s := range seeds { f.Add(s) } f.Fuzz(func(t *testing.T, original []byte) { validOriginal := utf8.Valid(original) modes := []struct { name string ansi7Bit bool ansi8Bit bool }{ {name: "off", ansi7Bit: false, ansi8Bit: false}, {name: "7bit", ansi7Bit: true, ansi8Bit: false}, {name: "8bit", ansi7Bit: false, ansi8Bit: true}, {name: "both", ansi7Bit: true, ansi8Bit: true}, } for _, mode := range modes { tokens := graphemes.FromBytes(original) tokens.AnsiEscapeSequences = mode.ansi7Bit tokens.AnsiEscapeSequences8Bit = mode.ansi8Bit var all [][]byte for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Fatalf("%s mode: bytes did not roundtrip", mode.name) } if validOriginal != utf8.Valid(roundtrip) { t.Fatalf("%s mode: utf8 validity of original did not match roundtrip", mode.name) } } }) } golang-github-clipperhouse-uax29-2.7.0/graphemes/iterator.go000066400000000000000000000071701515045622700240640ustar00rootroot00000000000000package graphemes import "unicode/utf8" // FromString returns an iterator for the grapheme clusters in the input string. // Iterate while Next() is true, and access the grapheme via Value(). func FromString(s string) *Iterator[string] { return &Iterator[string]{ split: splitFuncString, data: s, } } // FromBytes returns an iterator for the grapheme clusters in the input bytes. // Iterate while Next() is true, and access the grapheme via Value(). func FromBytes(b []byte) *Iterator[[]byte] { return &Iterator[[]byte]{ split: splitFuncBytes, data: b, } } // Iterator is a generic iterator for grapheme clusters in strings or byte slices, // with an ASCII hot path optimization. type Iterator[T ~string | ~[]byte] struct { split func(T, bool) (int, T, error) data T pos int start int // AnsiEscapeSequences treats 7-bit ANSI escape sequences (ECMA-48) as // single grapheme clusters when true. The default is false. // // 8-bit controls are not enabled by this option. See [AnsiEscapeSequences8Bit]. AnsiEscapeSequences bool // AnsiEscapeSequences8Bit treats 8-bit C1 ANSI escape sequences (ECMA-48) as single // grapheme clusters when true. The default is false. // // 8-bit control bytes are not UTF-8 encoded, i.e. not valid UTF-8. If you // choose this option, you are choosing to interpret non-UTF-8 data, caveat // emptor. AnsiEscapeSequences8Bit bool } var ( splitFuncString = splitFunc[string] splitFuncBytes = splitFunc[[]byte] ) const ( esc = 0x1B cr = 0x0D bel = 0x07 can = 0x18 sub = 0x1A st = 0x9C ) // Next advances the iterator to the next grapheme cluster. // Returns false when there are no more grapheme clusters. func (iter *Iterator[T]) Next() bool { if iter.pos >= len(iter.data) { return false } iter.start = iter.pos b := iter.data[iter.pos] if iter.AnsiEscapeSequences && b == esc { if a := ansiEscapeLength(iter.data[iter.pos:]); a > 0 { iter.pos += a return true } } if iter.AnsiEscapeSequences8Bit && b >= 0x80 && b <= 0x9F { if a := ansiEscapeLength8Bit(iter.data[iter.pos:]); a > 0 { iter.pos += a return true } } // ASCII hot path: any ASCII is one grapheme when next byte is ASCII or end. if b < utf8.RuneSelf && b != cr { if iter.pos+1 >= len(iter.data) || iter.data[iter.pos+1] < utf8.RuneSelf { iter.pos++ return true } } // Fall back to UAX29 grapheme parsing remaining := iter.data[iter.pos:] advance, _, err := iter.split(remaining, true) if err != nil { panic(err) } if advance <= 0 { panic("splitFunc returned a zero or negative advance") } iter.pos += advance if iter.pos > len(iter.data) { panic("splitFunc advanced beyond end of data") } return true } // Value returns the current grapheme cluster. func (iter *Iterator[T]) Value() T { return iter.data[iter.start:iter.pos] } // Start returns the byte position of the current grapheme in the original data. func (iter *Iterator[T]) Start() int { return iter.start } // End returns the byte position after the current grapheme in the original data. func (iter *Iterator[T]) End() int { return iter.pos } // Reset resets the iterator to the beginning of the data. func (iter *Iterator[T]) Reset() { iter.start = 0 iter.pos = 0 } // SetText sets the data for the iterator to operate on, and resets all state. func (iter *Iterator[T]) SetText(data T) { iter.data = data iter.start = 0 iter.pos = 0 } // First returns the first grapheme cluster without advancing the iterator. func (iter *Iterator[T]) First() T { if len(iter.data) == 0 { return iter.data } // Use a copy to leverage Next()'s ASCII optimization cp := *iter cp.pos = 0 cp.start = 0 cp.Next() return cp.Value() } golang-github-clipperhouse-uax29-2.7.0/graphemes/reader.go000066400000000000000000000011421515045622700234660ustar00rootroot00000000000000// Package graphemes implements Unicode grapheme cluster boundaries: https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries package graphemes import ( "bufio" "io" ) type Scanner struct { *bufio.Scanner } // FromReader returns a Scanner, to split graphemes per // https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries. // // It embeds a [bufio.Scanner], so you can use its methods. // // Iterate through graphemes by calling Scan() until false, then check Err(). func FromReader(r io.Reader) *Scanner { sc := bufio.NewScanner(r) sc.Split(SplitFunc) return &Scanner{ Scanner: sc, } } golang-github-clipperhouse-uax29-2.7.0/graphemes/reader_test.go000066400000000000000000000100771515045622700245340ustar00rootroot00000000000000package graphemes_test import ( "bytes" "crypto/rand" mathrand "math/rand" "reflect" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/graphemes" "github.com/clipperhouse/uax29/v2/testdata" ) func TestScannerUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { test := test var got [][]byte sc := graphemes.FromReader(bytes.NewReader(test.input)) for sc.Scan() { got = append(got, sc.Bytes()) } if err := sc.Err(); err != nil { t.Fatal(err) } if !reflect.DeepEqual(got, test.expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, got, test.comment) } else { passed++ } } t.Logf("passed %d, failed %d", passed, failed) } // TestScannerRoundtrip tests that all input bytes are output after iteration. func TestScannerRoundtrip(t *testing.T) { t.Parallel() const runs = 2_000 for i := 0; i < runs; i++ { input := getRandomBytes() r := bytes.NewReader(input) sc := graphemes.FromReader(r) var output []byte for sc.Scan() { output = append(output, sc.Bytes()...) } if err := sc.Err(); err != nil { t.Fatal(err) } if !bytes.Equal(output, input) { t.Fatal("input bytes are not the same as scanned bytes") } } } func TestInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() inlen := len(input) if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } r := bytes.NewReader(input) sc := graphemes.FromReader(r) var output []byte for sc.Scan() { output = append(output, sc.Bytes()...) } if err := sc.Err(); err != nil { t.Error(err) } outlen := len(output) if inlen != outlen { t.Fatalf("input: %d bytes, output: %d bytes", inlen, outlen) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as scanned bytes") } } func TestNeverZeroAtEOF(t *testing.T) { t.Parallel() // SplitFunc should never return advance = 0 when atEOF. This test is redundant // with the roundtrip test above, but nice to call out this invariant. const runs = 50 atEOF := true for i := 0; i < runs; i++ { input := getRandomBytes() advance, _, _ := graphemes.SplitFunc(input, atEOF) if advance == 0 { t.Errorf("advance should never be zero (atEOF %t)", atEOF) } } } func TestNeverErr(t *testing.T) { t.Parallel() // SplitFunc should never return an error. This test is redundant // with the roundtrip test above, but nice to call out this invariant. const runs = 50 atEOFs := []bool{true, false} for i := 0; i < runs; i++ { for _, atEOF := range atEOFs { input := getRandomBytes() _, _, err := graphemes.SplitFunc(input, atEOF) if err != nil { t.Errorf("SplitFunc should never error (atEOF %t)", atEOF) } } } } func getRandomBytes() []byte { const max = 10000 const min = 1 len := mathrand.Intn(max-min) + min b := make([]byte, len) _, _ = rand.Read(b) return b } func BenchmarkScanner(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } b.ResetTimer() b.SetBytes(int64(len(file))) r := bytes.NewReader(file) for i := 0; i < b.N; i++ { r.Reset(file) tokens := graphemes.FromReader(r) c := 0 for tokens.Scan() { c++ } if err := tokens.Err(); err != nil { b.Error(err) } b.ReportMetric(float64(c), "tokens") } } func BenchmarkUnicodeScanner(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() b.ResetTimer() b.SetBytes(int64(len(file))) r := bytes.NewReader(file) for i := 0; i < b.N; i++ { r.Reset(file) tokens := graphemes.FromReader(r) c := 0 for tokens.Scan() { c++ } if err := tokens.Err(); err != nil { b.Error(err) } b.ReportMetric(float64(c), "tokens") } } golang-github-clipperhouse-uax29-2.7.0/graphemes/splitfunc.go000066400000000000000000000117211515045622700242370ustar00rootroot00000000000000package graphemes import ( "bufio" ) // is determines if lookup intersects propert(ies) func (lookup property) is(properties property) bool { return (lookup & properties) != 0 } const _Ignore = _Extend // incbState tracks state for GB9c rule (Indic conjunct clusters) // Pattern: Consonant (Extend|Linker)* Linker (Extend|Linker)* × Consonant type incbState int const ( incbNone incbState = iota // initial/reset incbConsonant // seen Consonant, awaiting Linker incbLinker // seen Consonant and Linker (conjunct ready) ) // SplitFunc is a bufio.SplitFunc implementation of Unicode grapheme cluster segmentation, for use with bufio.Scanner. // // See https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries. var SplitFunc bufio.SplitFunc = splitFunc[[]byte] func splitFunc[T ~string | ~[]byte](data T, atEOF bool) (advance int, token T, err error) { var empty T if len(data) == 0 { return 0, empty, nil } // These vars are stateful across loop iterations var pos int var lastExIgnore property = 0 // "last excluding ignored categories" var lastLastExIgnore property = 0 // "last one before that" var regionalIndicatorCount int // GB9c state: tracking Indic conjunct clusters var incb incbState // Rules are usually of the form Cat1 × Cat2; "current" refers to the first property // to the right of the ×, from which we look back or forward current, w := lookup(data[pos:]) if w == 0 { if !atEOF { // Rune extends past current data, request more return 0, empty, nil } pos = len(data) return pos, data[:pos], nil } // https://unicode.org/reports/tr29/#GB1 // Start of text always advances pos += w for { eot := pos == len(data) // "end of text" if eot { if !atEOF { // Token extends past current data, request more return 0, empty, nil } // https://unicode.org/reports/tr29/#GB2 break } /* We've switched the evaluation order of GB1↓ and GB2↑. It's ok: because we've checked for len(data) at the top of this function, sot and eot are mutually exclusive, order doesn't matter. */ // Rules are usually of the form Cat1 × Cat2; "current" refers to the first property // to the right of the ×, from which we look back or forward // Remember previous properties to avoid lookups/lookbacks last := current if !last.is(_Ignore) { lastLastExIgnore = lastExIgnore lastExIgnore = last } // Update GB9c state based on what we just advanced past if last.is(_InCBConsonant | _InCBLinker | _InCBExtend) { switch { case last.is(_InCBConsonant): if incb != incbLinker { incb = incbConsonant } case last.is(_InCBLinker): if incb >= incbConsonant { incb = incbLinker } // case last.is(_InCBExtend): stay in current state } } else { incb = incbNone } current, w = lookup(data[pos:]) if w == 0 { if atEOF { // Just return the bytes, we can't do anything with them pos = len(data) break } // Rune extends past current data, request more return 0, empty, nil } // Optimization: no rule can possibly apply if current|last == 0 { // i.e. both are zero break } // https://unicode.org/reports/tr29/#GB3 if current.is(_LF) && last.is(_CR) { pos += w continue } // https://unicode.org/reports/tr29/#GB4 // https://unicode.org/reports/tr29/#GB5 if (current | last).is(_Control | _CR | _LF) { break } // https://unicode.org/reports/tr29/#GB6 if current.is(_L|_V|_LV|_LVT) && last.is(_L) { pos += w continue } // https://unicode.org/reports/tr29/#GB7 if current.is(_V|_T) && last.is(_LV|_V) { pos += w continue } // https://unicode.org/reports/tr29/#GB8 if current.is(_T) && last.is(_LVT|_T) { pos += w continue } // https://unicode.org/reports/tr29/#GB9 if current.is(_Extend | _ZWJ) { pos += w continue } // https://unicode.org/reports/tr29/#GB9a if current.is(_SpacingMark) { pos += w continue } // https://unicode.org/reports/tr29/#GB9b if last.is(_Prepend) { pos += w continue } // https://unicode.org/reports/tr29/#GB9c // Do not break within certain combinations with Indic_Conjunct_Break (InCB)=Linker. if incb == incbLinker && current.is(_InCBConsonant) { // After matching the pattern, reset state to start tracking a new pattern // The current Consonant becomes the start of the new pattern incb = incbConsonant pos += w continue } // https://unicode.org/reports/tr29/#GB11 if current.is(_ExtendedPictographic) && last.is(_ZWJ) && lastLastExIgnore.is(_ExtendedPictographic) { pos += w continue } // https://unicode.org/reports/tr29/#GB12 // https://unicode.org/reports/tr29/#GB13 if (current & last).is(_RegionalIndicator) { regionalIndicatorCount++ odd := regionalIndicatorCount%2 == 1 if odd { pos += w continue } } // If we fall through all the above rules, it's a grapheme cluster break break } // Return token return pos, data[:pos], nil } golang-github-clipperhouse-uax29-2.7.0/graphemes/string_test.go000066400000000000000000000131511515045622700245740ustar00rootroot00000000000000package graphemes_test import ( "bytes" "reflect" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/graphemes" "github.com/clipperhouse/uax29/v2/testdata" ) func TestStringUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { test := test var all []string tokens := graphemes.FromString(string(test.input)) for tokens.Next() { all = append(all, tokens.Value()) } expected := make([]string, len(test.expected)) for i, v := range test.expected { expected[i] = string(v) } if !reflect.DeepEqual(all, expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, all, test.comment) } else { passed++ } } if len(unicodeTests) != passed+failed { t.Errorf("Incomplete %d tests: passed %d, failed %d", len(unicodeTests), passed, failed) } } func TestStringRoundtrip(t *testing.T) { t.Parallel() const runs = 100 for i := 0; i < runs; i++ { input := string(getRandomBytes()) tokens := graphemes.FromString(input) var output string for tokens.Next() { output += tokens.Value() } if output != input { t.Fatal("input bytes are not the same as output bytes") } } } func TestStringInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } tokens := graphemes.FromString(string(input)) var output string for tokens.Next() { output += tokens.Value() } if output != string(input) { t.Fatalf("input bytes are not the same as output bytes") } } func TestFirst(t *testing.T) { t.Parallel() tests := []struct { name string input string expected string }{ { name: "ASCII start", input: "héllo world", expected: "h", }, { name: "combining character", input: "Élvis", expected: "É", }, { name: "empty string", input: "", expected: "", }, { name: "single ASCII char", input: "a", expected: "a", }, { name: "pure ASCII", input: "hello", expected: "h", }, { name: "emoji", input: "🎉 party", expected: "🎉", }, { name: "CJK", input: "日本語", expected: "日", }, } for _, tt := range tests { t.Run(tt.name+"/string", func(t *testing.T) { g := graphemes.FromString(tt.input) if g.First() != tt.expected { t.Errorf("expected %q, got %q", tt.expected, g.First()) } }) t.Run(tt.name+"/bytes", func(t *testing.T) { g := graphemes.FromBytes([]byte(tt.input)) if string(g.First()) != tt.expected { t.Errorf("expected %q, got %q", tt.expected, g.First()) } }) } } func TestFirstASCIIOptimization(t *testing.T) { t.Parallel() tests := []struct { name string input string expected string }{ // Pure ASCII hot path cases { name: "single printable ASCII", input: "a", expected: "a", }, { name: "ASCII followed by ASCII", input: "ab", expected: "a", }, { name: "ASCII space", input: " hello", expected: " ", }, { name: "ASCII digit", input: "5abc", expected: "5", }, { name: "ASCII punctuation", input: "!hello", expected: "!", }, // Fallback cases (non-ASCII or combining marks) { name: "ASCII then non-ASCII", input: "a日", expected: "a", }, { name: "ASCII followed by combining mark", input: "e\u0301", // e + combining acute = é expected: "e\u0301", }, { name: "non-ASCII start", input: "日本", expected: "日", }, { name: "emoji grapheme cluster", input: "👨‍👩‍👧‍👦 family", expected: "👨‍👩‍👧‍👦", }, { name: "flag emoji", input: "🇺🇸 USA", expected: "🇺🇸", }, // Edge cases { name: "control char (below 0x20)", input: "\t hello", expected: "\t", }, { name: "DEL char (0x7F)", input: "\x7Fhello", expected: "\x7F", }, { name: "high ASCII then combining", input: "n\u0303", // n + combining tilde = ñ expected: "n\u0303", }, } for _, tt := range tests { t.Run(tt.name+"/string", func(t *testing.T) { iter := graphemes.FromString(tt.input) got := iter.First() if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) t.Run(tt.name+"/bytes", func(t *testing.T) { iter := graphemes.FromBytes([]byte(tt.input)) got := string(iter.First()) if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) } } func BenchmarkString(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } s := string(file) b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := graphemes.FromString(s) c := 0 for tokens.Next() { _ = tokens.Value() c++ } b.ReportMetric(float64(c), "tokens") } } func BenchmarkStringUnicodeTests(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() s := string(file) b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := graphemes.FromString(s) c := 0 for tokens.Next() { _ = tokens.Value() c++ } b.ReportMetric(float64(c), "tokens") } } golang-github-clipperhouse-uax29-2.7.0/graphemes/trie.go000066400000000000000000003134051515045622700231770ustar00rootroot00000000000000package graphemes // generated by github.com/clipperhouse/uax29/v2 // from https://www.unicode.org/Public/17.0.0/ucd/auxiliary/GraphemeBreakProperty.txt type property uint32 const ( _CR property = 1 << iota _Control _Extend _ExtendedPictographic _InCBConsonant _InCBExtend _InCBLinker _L _LF _LV _LVT _Prepend _RegionalIndicator _SpacingMark _T _V _ZWJ ) // 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 lookup[T ~string | ~[]byte](s T) (v property, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return graphemesValues[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := graphemesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := graphemesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = graphemesIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := graphemesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = graphemesIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = graphemesIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // graphemesTrie. Total size: 61760 bytes (60.31 KiB). Checksum: af733ba94cd94ba6. // type graphemesTrie struct { } // func newGraphemesTrie(i int) *graphemesTrie { // return &graphemesTrie{} // } // lookupValue determines the type of block n and looks up the value for b. func lookupValue(n uint32, b byte) property { switch { default: return property(graphemesValues[n<<6+uint32(b)]) } } // graphemesValues: 235 blocks, 15040 entries, 60160 bytes // The third block is the zero block. var graphemesValues = [15040]property{ // Block 0x0, offset 0x0 0x00: 0x0002, 0x01: 0x0002, 0x02: 0x0002, 0x03: 0x0002, 0x04: 0x0002, 0x05: 0x0002, 0x06: 0x0002, 0x07: 0x0002, 0x08: 0x0002, 0x09: 0x0002, 0x0a: 0x0100, 0x0b: 0x0002, 0x0c: 0x0002, 0x0d: 0x0001, 0x0e: 0x0002, 0x0f: 0x0002, 0x10: 0x0002, 0x11: 0x0002, 0x12: 0x0002, 0x13: 0x0002, 0x14: 0x0002, 0x15: 0x0002, 0x16: 0x0002, 0x17: 0x0002, 0x18: 0x0002, 0x19: 0x0002, 0x1a: 0x0002, 0x1b: 0x0002, 0x1c: 0x0002, 0x1d: 0x0002, 0x1e: 0x0002, 0x1f: 0x0002, // Block 0x1, offset 0x40 0x7f: 0x0002, // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc0: 0x0002, 0xc1: 0x0002, 0xc2: 0x0002, 0xc3: 0x0002, 0xc4: 0x0002, 0xc5: 0x0002, 0xc6: 0x0002, 0xc7: 0x0002, 0xc8: 0x0002, 0xc9: 0x0002, 0xca: 0x0002, 0xcb: 0x0002, 0xcc: 0x0002, 0xcd: 0x0002, 0xce: 0x0002, 0xcf: 0x0002, 0xd0: 0x0002, 0xd1: 0x0002, 0xd2: 0x0002, 0xd3: 0x0002, 0xd4: 0x0002, 0xd5: 0x0002, 0xd6: 0x0002, 0xd7: 0x0002, 0xd8: 0x0002, 0xd9: 0x0002, 0xda: 0x0002, 0xdb: 0x0002, 0xdc: 0x0002, 0xdd: 0x0002, 0xde: 0x0002, 0xdf: 0x0002, 0xe9: 0x0008, 0xed: 0x0002, 0xee: 0x0008, // Block 0x4, offset 0x100 0x100: 0x0024, 0x101: 0x0024, 0x102: 0x0024, 0x103: 0x0024, 0x104: 0x0024, 0x105: 0x0024, 0x106: 0x0024, 0x107: 0x0024, 0x108: 0x0024, 0x109: 0x0024, 0x10a: 0x0024, 0x10b: 0x0024, 0x10c: 0x0024, 0x10d: 0x0024, 0x10e: 0x0024, 0x10f: 0x0024, 0x110: 0x0024, 0x111: 0x0024, 0x112: 0x0024, 0x113: 0x0024, 0x114: 0x0024, 0x115: 0x0024, 0x116: 0x0024, 0x117: 0x0024, 0x118: 0x0024, 0x119: 0x0024, 0x11a: 0x0024, 0x11b: 0x0024, 0x11c: 0x0024, 0x11d: 0x0024, 0x11e: 0x0024, 0x11f: 0x0024, 0x120: 0x0024, 0x121: 0x0024, 0x122: 0x0024, 0x123: 0x0024, 0x124: 0x0024, 0x125: 0x0024, 0x126: 0x0024, 0x127: 0x0024, 0x128: 0x0024, 0x129: 0x0024, 0x12a: 0x0024, 0x12b: 0x0024, 0x12c: 0x0024, 0x12d: 0x0024, 0x12e: 0x0024, 0x12f: 0x0024, 0x130: 0x0024, 0x131: 0x0024, 0x132: 0x0024, 0x133: 0x0024, 0x134: 0x0024, 0x135: 0x0024, 0x136: 0x0024, 0x137: 0x0024, 0x138: 0x0024, 0x139: 0x0024, 0x13a: 0x0024, 0x13b: 0x0024, 0x13c: 0x0024, 0x13d: 0x0024, 0x13e: 0x0024, 0x13f: 0x0024, // Block 0x5, offset 0x140 0x140: 0x0024, 0x141: 0x0024, 0x142: 0x0024, 0x143: 0x0024, 0x144: 0x0024, 0x145: 0x0024, 0x146: 0x0024, 0x147: 0x0024, 0x148: 0x0024, 0x149: 0x0024, 0x14a: 0x0024, 0x14b: 0x0024, 0x14c: 0x0024, 0x14d: 0x0024, 0x14e: 0x0024, 0x14f: 0x0024, 0x150: 0x0024, 0x151: 0x0024, 0x152: 0x0024, 0x153: 0x0024, 0x154: 0x0024, 0x155: 0x0024, 0x156: 0x0024, 0x157: 0x0024, 0x158: 0x0024, 0x159: 0x0024, 0x15a: 0x0024, 0x15b: 0x0024, 0x15c: 0x0024, 0x15d: 0x0024, 0x15e: 0x0024, 0x15f: 0x0024, 0x160: 0x0024, 0x161: 0x0024, 0x162: 0x0024, 0x163: 0x0024, 0x164: 0x0024, 0x165: 0x0024, 0x166: 0x0024, 0x167: 0x0024, 0x168: 0x0024, 0x169: 0x0024, 0x16a: 0x0024, 0x16b: 0x0024, 0x16c: 0x0024, 0x16d: 0x0024, 0x16e: 0x0024, 0x16f: 0x0024, // Block 0x6, offset 0x180 0x183: 0x0024, 0x184: 0x0024, 0x185: 0x0024, 0x186: 0x0024, 0x187: 0x0024, 0x188: 0x0024, 0x189: 0x0024, // Block 0x7, offset 0x1c0 0x1d1: 0x0024, 0x1d2: 0x0024, 0x1d3: 0x0024, 0x1d4: 0x0024, 0x1d5: 0x0024, 0x1d6: 0x0024, 0x1d7: 0x0024, 0x1d8: 0x0024, 0x1d9: 0x0024, 0x1da: 0x0024, 0x1db: 0x0024, 0x1dc: 0x0024, 0x1dd: 0x0024, 0x1de: 0x0024, 0x1df: 0x0024, 0x1e0: 0x0024, 0x1e1: 0x0024, 0x1e2: 0x0024, 0x1e3: 0x0024, 0x1e4: 0x0024, 0x1e5: 0x0024, 0x1e6: 0x0024, 0x1e7: 0x0024, 0x1e8: 0x0024, 0x1e9: 0x0024, 0x1ea: 0x0024, 0x1eb: 0x0024, 0x1ec: 0x0024, 0x1ed: 0x0024, 0x1ee: 0x0024, 0x1ef: 0x0024, 0x1f0: 0x0024, 0x1f1: 0x0024, 0x1f2: 0x0024, 0x1f3: 0x0024, 0x1f4: 0x0024, 0x1f5: 0x0024, 0x1f6: 0x0024, 0x1f7: 0x0024, 0x1f8: 0x0024, 0x1f9: 0x0024, 0x1fa: 0x0024, 0x1fb: 0x0024, 0x1fc: 0x0024, 0x1fd: 0x0024, 0x1ff: 0x0024, // Block 0x8, offset 0x200 0x201: 0x0024, 0x202: 0x0024, 0x204: 0x0024, 0x205: 0x0024, 0x207: 0x0024, // Block 0x9, offset 0x240 0x240: 0x0800, 0x241: 0x0800, 0x242: 0x0800, 0x243: 0x0800, 0x244: 0x0800, 0x245: 0x0800, 0x250: 0x0024, 0x251: 0x0024, 0x252: 0x0024, 0x253: 0x0024, 0x254: 0x0024, 0x255: 0x0024, 0x256: 0x0024, 0x257: 0x0024, 0x258: 0x0024, 0x259: 0x0024, 0x25a: 0x0024, 0x25c: 0x0002, // Block 0xa, offset 0x280 0x28b: 0x0024, 0x28c: 0x0024, 0x28d: 0x0024, 0x28e: 0x0024, 0x28f: 0x0024, 0x290: 0x0024, 0x291: 0x0024, 0x292: 0x0024, 0x293: 0x0024, 0x294: 0x0024, 0x295: 0x0024, 0x296: 0x0024, 0x297: 0x0024, 0x298: 0x0024, 0x299: 0x0024, 0x29a: 0x0024, 0x29b: 0x0024, 0x29c: 0x0024, 0x29d: 0x0024, 0x29e: 0x0024, 0x29f: 0x0024, 0x2b0: 0x0024, // Block 0xb, offset 0x2c0 0x2d6: 0x0024, 0x2d7: 0x0024, 0x2d8: 0x0024, 0x2d9: 0x0024, 0x2da: 0x0024, 0x2db: 0x0024, 0x2dc: 0x0024, 0x2dd: 0x0800, 0x2df: 0x0024, 0x2e0: 0x0024, 0x2e1: 0x0024, 0x2e2: 0x0024, 0x2e3: 0x0024, 0x2e4: 0x0024, 0x2e7: 0x0024, 0x2e8: 0x0024, 0x2ea: 0x0024, 0x2eb: 0x0024, 0x2ec: 0x0024, 0x2ed: 0x0024, // Block 0xc, offset 0x300 0x30f: 0x0800, 0x311: 0x0024, 0x330: 0x0024, 0x331: 0x0024, 0x332: 0x0024, 0x333: 0x0024, 0x334: 0x0024, 0x335: 0x0024, 0x336: 0x0024, 0x337: 0x0024, 0x338: 0x0024, 0x339: 0x0024, 0x33a: 0x0024, 0x33b: 0x0024, 0x33c: 0x0024, 0x33d: 0x0024, 0x33e: 0x0024, 0x33f: 0x0024, // Block 0xd, offset 0x340 0x340: 0x0024, 0x341: 0x0024, 0x342: 0x0024, 0x343: 0x0024, 0x344: 0x0024, 0x345: 0x0024, 0x346: 0x0024, 0x347: 0x0024, 0x348: 0x0024, 0x349: 0x0024, 0x34a: 0x0024, // Block 0xe, offset 0x380 0x3a6: 0x0024, 0x3a7: 0x0024, 0x3a8: 0x0024, 0x3a9: 0x0024, 0x3aa: 0x0024, 0x3ab: 0x0024, 0x3ac: 0x0024, 0x3ad: 0x0024, 0x3ae: 0x0024, 0x3af: 0x0024, 0x3b0: 0x0024, // Block 0xf, offset 0x3c0 0x3eb: 0x0024, 0x3ec: 0x0024, 0x3ed: 0x0024, 0x3ee: 0x0024, 0x3ef: 0x0024, 0x3f0: 0x0024, 0x3f1: 0x0024, 0x3f2: 0x0024, 0x3f3: 0x0024, 0x3fd: 0x0024, // Block 0x10, offset 0x400 0x416: 0x0024, 0x417: 0x0024, 0x418: 0x0024, 0x419: 0x0024, 0x41b: 0x0024, 0x41c: 0x0024, 0x41d: 0x0024, 0x41e: 0x0024, 0x41f: 0x0024, 0x420: 0x0024, 0x421: 0x0024, 0x422: 0x0024, 0x423: 0x0024, 0x425: 0x0024, 0x426: 0x0024, 0x427: 0x0024, 0x429: 0x0024, 0x42a: 0x0024, 0x42b: 0x0024, 0x42c: 0x0024, 0x42d: 0x0024, // Block 0x11, offset 0x440 0x459: 0x0024, 0x45a: 0x0024, 0x45b: 0x0024, // Block 0x12, offset 0x480 0x490: 0x0800, 0x491: 0x0800, 0x497: 0x0024, 0x498: 0x0024, 0x499: 0x0024, 0x49a: 0x0024, 0x49b: 0x0024, 0x49c: 0x0024, 0x49d: 0x0024, 0x49e: 0x0024, 0x49f: 0x0024, // Block 0x13, offset 0x4c0 0x4ca: 0x0024, 0x4cb: 0x0024, 0x4cc: 0x0024, 0x4cd: 0x0024, 0x4ce: 0x0024, 0x4cf: 0x0024, 0x4d0: 0x0024, 0x4d1: 0x0024, 0x4d2: 0x0024, 0x4d3: 0x0024, 0x4d4: 0x0024, 0x4d5: 0x0024, 0x4d6: 0x0024, 0x4d7: 0x0024, 0x4d8: 0x0024, 0x4d9: 0x0024, 0x4da: 0x0024, 0x4db: 0x0024, 0x4dc: 0x0024, 0x4dd: 0x0024, 0x4de: 0x0024, 0x4df: 0x0024, 0x4e0: 0x0024, 0x4e1: 0x0024, 0x4e2: 0x0800, 0x4e3: 0x0024, 0x4e4: 0x0024, 0x4e5: 0x0024, 0x4e6: 0x0024, 0x4e7: 0x0024, 0x4e8: 0x0024, 0x4e9: 0x0024, 0x4ea: 0x0024, 0x4eb: 0x0024, 0x4ec: 0x0024, 0x4ed: 0x0024, 0x4ee: 0x0024, 0x4ef: 0x0024, 0x4f0: 0x0024, 0x4f1: 0x0024, 0x4f2: 0x0024, 0x4f3: 0x0024, 0x4f4: 0x0024, 0x4f5: 0x0024, 0x4f6: 0x0024, 0x4f7: 0x0024, 0x4f8: 0x0024, 0x4f9: 0x0024, 0x4fa: 0x0024, 0x4fb: 0x0024, 0x4fc: 0x0024, 0x4fd: 0x0024, 0x4fe: 0x0024, 0x4ff: 0x0024, // Block 0x14, offset 0x500 0x500: 0x0024, 0x501: 0x0024, 0x502: 0x0024, 0x503: 0x2000, 0x515: 0x0010, 0x516: 0x0010, 0x517: 0x0010, 0x518: 0x0010, 0x519: 0x0010, 0x51a: 0x0010, 0x51b: 0x0010, 0x51c: 0x0010, 0x51d: 0x0010, 0x51e: 0x0010, 0x51f: 0x0010, 0x520: 0x0010, 0x521: 0x0010, 0x522: 0x0010, 0x523: 0x0010, 0x524: 0x0010, 0x525: 0x0010, 0x526: 0x0010, 0x527: 0x0010, 0x528: 0x0010, 0x529: 0x0010, 0x52a: 0x0010, 0x52b: 0x0010, 0x52c: 0x0010, 0x52d: 0x0010, 0x52e: 0x0010, 0x52f: 0x0010, 0x530: 0x0010, 0x531: 0x0010, 0x532: 0x0010, 0x533: 0x0010, 0x534: 0x0010, 0x535: 0x0010, 0x536: 0x0010, 0x537: 0x0010, 0x538: 0x0010, 0x539: 0x0010, 0x53a: 0x0024, 0x53b: 0x2000, 0x53c: 0x0024, 0x53e: 0x2000, 0x53f: 0x2000, // Block 0x15, offset 0x540 0x540: 0x2000, 0x541: 0x0024, 0x542: 0x0024, 0x543: 0x0024, 0x544: 0x0024, 0x545: 0x0024, 0x546: 0x0024, 0x547: 0x0024, 0x548: 0x0024, 0x549: 0x2000, 0x54a: 0x2000, 0x54b: 0x2000, 0x54c: 0x2000, 0x54d: 0x0044, 0x54e: 0x2000, 0x54f: 0x2000, 0x551: 0x0024, 0x552: 0x0024, 0x553: 0x0024, 0x554: 0x0024, 0x555: 0x0024, 0x556: 0x0024, 0x557: 0x0024, 0x558: 0x0010, 0x559: 0x0010, 0x55a: 0x0010, 0x55b: 0x0010, 0x55c: 0x0010, 0x55d: 0x0010, 0x55e: 0x0010, 0x55f: 0x0010, 0x562: 0x0024, 0x563: 0x0024, 0x578: 0x0010, 0x579: 0x0010, 0x57a: 0x0010, 0x57b: 0x0010, 0x57c: 0x0010, 0x57d: 0x0010, 0x57e: 0x0010, 0x57f: 0x0010, // Block 0x16, offset 0x580 0x581: 0x0024, 0x582: 0x2000, 0x583: 0x2000, 0x595: 0x0010, 0x596: 0x0010, 0x597: 0x0010, 0x598: 0x0010, 0x599: 0x0010, 0x59a: 0x0010, 0x59b: 0x0010, 0x59c: 0x0010, 0x59d: 0x0010, 0x59e: 0x0010, 0x59f: 0x0010, 0x5a0: 0x0010, 0x5a1: 0x0010, 0x5a2: 0x0010, 0x5a3: 0x0010, 0x5a4: 0x0010, 0x5a5: 0x0010, 0x5a6: 0x0010, 0x5a7: 0x0010, 0x5a8: 0x0010, 0x5aa: 0x0010, 0x5ab: 0x0010, 0x5ac: 0x0010, 0x5ad: 0x0010, 0x5ae: 0x0010, 0x5af: 0x0010, 0x5b0: 0x0010, 0x5b2: 0x0010, 0x5b6: 0x0010, 0x5b7: 0x0010, 0x5b8: 0x0010, 0x5b9: 0x0010, 0x5bc: 0x0024, 0x5be: 0x0024, 0x5bf: 0x2000, // Block 0x17, offset 0x5c0 0x5c0: 0x2000, 0x5c1: 0x0024, 0x5c2: 0x0024, 0x5c3: 0x0024, 0x5c4: 0x0024, 0x5c7: 0x2000, 0x5c8: 0x2000, 0x5cb: 0x2000, 0x5cc: 0x2000, 0x5cd: 0x0044, 0x5d7: 0x0024, 0x5dc: 0x0010, 0x5dd: 0x0010, 0x5df: 0x0010, 0x5e2: 0x0024, 0x5e3: 0x0024, 0x5f0: 0x0010, 0x5f1: 0x0010, 0x5fe: 0x0024, // Block 0x18, offset 0x600 0x601: 0x0024, 0x602: 0x0024, 0x603: 0x2000, 0x63c: 0x0024, 0x63e: 0x2000, 0x63f: 0x2000, // Block 0x19, offset 0x640 0x640: 0x2000, 0x641: 0x0024, 0x642: 0x0024, 0x647: 0x0024, 0x648: 0x0024, 0x64b: 0x0024, 0x64c: 0x0024, 0x64d: 0x0024, 0x651: 0x0024, 0x670: 0x0024, 0x671: 0x0024, 0x675: 0x0024, // Block 0x1a, offset 0x680 0x681: 0x0024, 0x682: 0x0024, 0x683: 0x2000, 0x695: 0x0010, 0x696: 0x0010, 0x697: 0x0010, 0x698: 0x0010, 0x699: 0x0010, 0x69a: 0x0010, 0x69b: 0x0010, 0x69c: 0x0010, 0x69d: 0x0010, 0x69e: 0x0010, 0x69f: 0x0010, 0x6a0: 0x0010, 0x6a1: 0x0010, 0x6a2: 0x0010, 0x6a3: 0x0010, 0x6a4: 0x0010, 0x6a5: 0x0010, 0x6a6: 0x0010, 0x6a7: 0x0010, 0x6a8: 0x0010, 0x6aa: 0x0010, 0x6ab: 0x0010, 0x6ac: 0x0010, 0x6ad: 0x0010, 0x6ae: 0x0010, 0x6af: 0x0010, 0x6b0: 0x0010, 0x6b2: 0x0010, 0x6b3: 0x0010, 0x6b5: 0x0010, 0x6b6: 0x0010, 0x6b7: 0x0010, 0x6b8: 0x0010, 0x6b9: 0x0010, 0x6bc: 0x0024, 0x6be: 0x2000, 0x6bf: 0x2000, // Block 0x1b, offset 0x6c0 0x6c0: 0x2000, 0x6c1: 0x0024, 0x6c2: 0x0024, 0x6c3: 0x0024, 0x6c4: 0x0024, 0x6c5: 0x0024, 0x6c7: 0x0024, 0x6c8: 0x0024, 0x6c9: 0x2000, 0x6cb: 0x2000, 0x6cc: 0x2000, 0x6cd: 0x0044, 0x6e2: 0x0024, 0x6e3: 0x0024, 0x6f9: 0x0010, 0x6fa: 0x0024, 0x6fb: 0x0024, 0x6fc: 0x0024, 0x6fd: 0x0024, 0x6fe: 0x0024, 0x6ff: 0x0024, // Block 0x1c, offset 0x700 0x701: 0x0024, 0x702: 0x2000, 0x703: 0x2000, 0x715: 0x0010, 0x716: 0x0010, 0x717: 0x0010, 0x718: 0x0010, 0x719: 0x0010, 0x71a: 0x0010, 0x71b: 0x0010, 0x71c: 0x0010, 0x71d: 0x0010, 0x71e: 0x0010, 0x71f: 0x0010, 0x720: 0x0010, 0x721: 0x0010, 0x722: 0x0010, 0x723: 0x0010, 0x724: 0x0010, 0x725: 0x0010, 0x726: 0x0010, 0x727: 0x0010, 0x728: 0x0010, 0x72a: 0x0010, 0x72b: 0x0010, 0x72c: 0x0010, 0x72d: 0x0010, 0x72e: 0x0010, 0x72f: 0x0010, 0x730: 0x0010, 0x732: 0x0010, 0x733: 0x0010, 0x735: 0x0010, 0x736: 0x0010, 0x737: 0x0010, 0x738: 0x0010, 0x739: 0x0010, 0x73c: 0x0024, 0x73e: 0x0024, 0x73f: 0x0024, // Block 0x1d, offset 0x740 0x740: 0x2000, 0x741: 0x0024, 0x742: 0x0024, 0x743: 0x0024, 0x744: 0x0024, 0x747: 0x2000, 0x748: 0x2000, 0x74b: 0x2000, 0x74c: 0x2000, 0x74d: 0x0044, 0x755: 0x0024, 0x756: 0x0024, 0x757: 0x0024, 0x75c: 0x0010, 0x75d: 0x0010, 0x75f: 0x0010, 0x762: 0x0024, 0x763: 0x0024, 0x771: 0x0010, // Block 0x1e, offset 0x780 0x782: 0x0024, 0x7be: 0x0024, 0x7bf: 0x2000, // Block 0x1f, offset 0x7c0 0x7c0: 0x0024, 0x7c1: 0x2000, 0x7c2: 0x2000, 0x7c6: 0x2000, 0x7c7: 0x2000, 0x7c8: 0x2000, 0x7ca: 0x2000, 0x7cb: 0x2000, 0x7cc: 0x2000, 0x7cd: 0x0024, 0x7d7: 0x0024, // Block 0x20, offset 0x800 0x800: 0x0024, 0x801: 0x2000, 0x802: 0x2000, 0x803: 0x2000, 0x804: 0x0024, 0x815: 0x0010, 0x816: 0x0010, 0x817: 0x0010, 0x818: 0x0010, 0x819: 0x0010, 0x81a: 0x0010, 0x81b: 0x0010, 0x81c: 0x0010, 0x81d: 0x0010, 0x81e: 0x0010, 0x81f: 0x0010, 0x820: 0x0010, 0x821: 0x0010, 0x822: 0x0010, 0x823: 0x0010, 0x824: 0x0010, 0x825: 0x0010, 0x826: 0x0010, 0x827: 0x0010, 0x828: 0x0010, 0x82a: 0x0010, 0x82b: 0x0010, 0x82c: 0x0010, 0x82d: 0x0010, 0x82e: 0x0010, 0x82f: 0x0010, 0x830: 0x0010, 0x831: 0x0010, 0x832: 0x0010, 0x833: 0x0010, 0x834: 0x0010, 0x835: 0x0010, 0x836: 0x0010, 0x837: 0x0010, 0x838: 0x0010, 0x839: 0x0010, 0x83c: 0x0024, 0x83e: 0x0024, 0x83f: 0x0024, // Block 0x21, offset 0x840 0x840: 0x0024, 0x841: 0x2000, 0x842: 0x2000, 0x843: 0x2000, 0x844: 0x2000, 0x846: 0x0024, 0x847: 0x0024, 0x848: 0x0024, 0x84a: 0x0024, 0x84b: 0x0024, 0x84c: 0x0024, 0x84d: 0x0044, 0x855: 0x0024, 0x856: 0x0024, 0x858: 0x0010, 0x859: 0x0010, 0x85a: 0x0010, 0x862: 0x0024, 0x863: 0x0024, // Block 0x22, offset 0x880 0x881: 0x0024, 0x882: 0x2000, 0x883: 0x2000, 0x8bc: 0x0024, 0x8be: 0x2000, 0x8bf: 0x0024, // Block 0x23, offset 0x8c0 0x8c0: 0x0024, 0x8c1: 0x2000, 0x8c2: 0x0024, 0x8c3: 0x2000, 0x8c4: 0x2000, 0x8c6: 0x0024, 0x8c7: 0x0024, 0x8c8: 0x0024, 0x8ca: 0x0024, 0x8cb: 0x0024, 0x8cc: 0x0024, 0x8cd: 0x0024, 0x8d5: 0x0024, 0x8d6: 0x0024, 0x8e2: 0x0024, 0x8e3: 0x0024, 0x8f3: 0x2000, // Block 0x24, offset 0x900 0x900: 0x0024, 0x901: 0x0024, 0x902: 0x2000, 0x903: 0x2000, 0x915: 0x0010, 0x916: 0x0010, 0x917: 0x0010, 0x918: 0x0010, 0x919: 0x0010, 0x91a: 0x0010, 0x91b: 0x0010, 0x91c: 0x0010, 0x91d: 0x0010, 0x91e: 0x0010, 0x91f: 0x0010, 0x920: 0x0010, 0x921: 0x0010, 0x922: 0x0010, 0x923: 0x0010, 0x924: 0x0010, 0x925: 0x0010, 0x926: 0x0010, 0x927: 0x0010, 0x928: 0x0010, 0x929: 0x0010, 0x92a: 0x0010, 0x92b: 0x0010, 0x92c: 0x0010, 0x92d: 0x0010, 0x92e: 0x0010, 0x92f: 0x0010, 0x930: 0x0010, 0x931: 0x0010, 0x932: 0x0010, 0x933: 0x0010, 0x934: 0x0010, 0x935: 0x0010, 0x936: 0x0010, 0x937: 0x0010, 0x938: 0x0010, 0x939: 0x0010, 0x93a: 0x0010, 0x93b: 0x0024, 0x93c: 0x0024, 0x93e: 0x0024, 0x93f: 0x2000, // Block 0x25, offset 0x940 0x940: 0x2000, 0x941: 0x0024, 0x942: 0x0024, 0x943: 0x0024, 0x944: 0x0024, 0x946: 0x2000, 0x947: 0x2000, 0x948: 0x2000, 0x94a: 0x2000, 0x94b: 0x2000, 0x94c: 0x2000, 0x94d: 0x0044, 0x94e: 0x0800, 0x957: 0x0024, 0x962: 0x0024, 0x963: 0x0024, // Block 0x26, offset 0x980 0x981: 0x0024, 0x982: 0x2000, 0x983: 0x2000, // Block 0x27, offset 0x9c0 0x9ca: 0x0024, 0x9cf: 0x0024, 0x9d0: 0x2000, 0x9d1: 0x2000, 0x9d2: 0x0024, 0x9d3: 0x0024, 0x9d4: 0x0024, 0x9d6: 0x0024, 0x9d8: 0x2000, 0x9d9: 0x2000, 0x9da: 0x2000, 0x9db: 0x2000, 0x9dc: 0x2000, 0x9dd: 0x2000, 0x9de: 0x2000, 0x9df: 0x0024, 0x9f2: 0x2000, 0x9f3: 0x2000, // Block 0x28, offset 0xa00 0xa31: 0x0024, 0xa33: 0x2000, 0xa34: 0x0024, 0xa35: 0x0024, 0xa36: 0x0024, 0xa37: 0x0024, 0xa38: 0x0024, 0xa39: 0x0024, 0xa3a: 0x0024, // Block 0x29, offset 0xa40 0xa47: 0x0024, 0xa48: 0x0024, 0xa49: 0x0024, 0xa4a: 0x0024, 0xa4b: 0x0024, 0xa4c: 0x0024, 0xa4d: 0x0024, 0xa4e: 0x0024, // Block 0x2a, offset 0xa80 0xab1: 0x0024, 0xab3: 0x2000, 0xab4: 0x0024, 0xab5: 0x0024, 0xab6: 0x0024, 0xab7: 0x0024, 0xab8: 0x0024, 0xab9: 0x0024, 0xaba: 0x0024, 0xabb: 0x0024, 0xabc: 0x0024, // Block 0x2b, offset 0xac0 0xac8: 0x0024, 0xac9: 0x0024, 0xaca: 0x0024, 0xacb: 0x0024, 0xacc: 0x0024, 0xacd: 0x0024, 0xace: 0x0024, // Block 0x2c, offset 0xb00 0xb18: 0x0024, 0xb19: 0x0024, 0xb35: 0x0024, 0xb37: 0x0024, 0xb39: 0x0024, 0xb3e: 0x2000, 0xb3f: 0x2000, // Block 0x2d, offset 0xb40 0xb71: 0x0024, 0xb72: 0x0024, 0xb73: 0x0024, 0xb74: 0x0024, 0xb75: 0x0024, 0xb76: 0x0024, 0xb77: 0x0024, 0xb78: 0x0024, 0xb79: 0x0024, 0xb7a: 0x0024, 0xb7b: 0x0024, 0xb7c: 0x0024, 0xb7d: 0x0024, 0xb7e: 0x0024, 0xb7f: 0x2000, // Block 0x2e, offset 0xb80 0xb80: 0x0024, 0xb81: 0x0024, 0xb82: 0x0024, 0xb83: 0x0024, 0xb84: 0x0024, 0xb86: 0x0024, 0xb87: 0x0024, 0xb8d: 0x0024, 0xb8e: 0x0024, 0xb8f: 0x0024, 0xb90: 0x0024, 0xb91: 0x0024, 0xb92: 0x0024, 0xb93: 0x0024, 0xb94: 0x0024, 0xb95: 0x0024, 0xb96: 0x0024, 0xb97: 0x0024, 0xb99: 0x0024, 0xb9a: 0x0024, 0xb9b: 0x0024, 0xb9c: 0x0024, 0xb9d: 0x0024, 0xb9e: 0x0024, 0xb9f: 0x0024, 0xba0: 0x0024, 0xba1: 0x0024, 0xba2: 0x0024, 0xba3: 0x0024, 0xba4: 0x0024, 0xba5: 0x0024, 0xba6: 0x0024, 0xba7: 0x0024, 0xba8: 0x0024, 0xba9: 0x0024, 0xbaa: 0x0024, 0xbab: 0x0024, 0xbac: 0x0024, 0xbad: 0x0024, 0xbae: 0x0024, 0xbaf: 0x0024, 0xbb0: 0x0024, 0xbb1: 0x0024, 0xbb2: 0x0024, 0xbb3: 0x0024, 0xbb4: 0x0024, 0xbb5: 0x0024, 0xbb6: 0x0024, 0xbb7: 0x0024, 0xbb8: 0x0024, 0xbb9: 0x0024, 0xbba: 0x0024, 0xbbb: 0x0024, 0xbbc: 0x0024, // Block 0x2f, offset 0xbc0 0xbc6: 0x0024, // Block 0x30, offset 0xc00 0xc00: 0x0010, 0xc01: 0x0010, 0xc02: 0x0010, 0xc03: 0x0010, 0xc04: 0x0010, 0xc05: 0x0010, 0xc06: 0x0010, 0xc07: 0x0010, 0xc08: 0x0010, 0xc09: 0x0010, 0xc0a: 0x0010, 0xc0b: 0x0010, 0xc0c: 0x0010, 0xc0d: 0x0010, 0xc0e: 0x0010, 0xc0f: 0x0010, 0xc10: 0x0010, 0xc11: 0x0010, 0xc12: 0x0010, 0xc13: 0x0010, 0xc14: 0x0010, 0xc15: 0x0010, 0xc16: 0x0010, 0xc17: 0x0010, 0xc18: 0x0010, 0xc19: 0x0010, 0xc1a: 0x0010, 0xc1b: 0x0010, 0xc1c: 0x0010, 0xc1d: 0x0010, 0xc1e: 0x0010, 0xc1f: 0x0010, 0xc20: 0x0010, 0xc21: 0x0010, 0xc22: 0x0010, 0xc23: 0x0010, 0xc24: 0x0010, 0xc25: 0x0010, 0xc26: 0x0010, 0xc27: 0x0010, 0xc28: 0x0010, 0xc29: 0x0010, 0xc2a: 0x0010, 0xc2d: 0x0024, 0xc2e: 0x0024, 0xc2f: 0x0024, 0xc30: 0x0024, 0xc31: 0x2000, 0xc32: 0x0024, 0xc33: 0x0024, 0xc34: 0x0024, 0xc35: 0x0024, 0xc36: 0x0024, 0xc37: 0x0024, 0xc39: 0x0044, 0xc3a: 0x0024, 0xc3b: 0x2000, 0xc3c: 0x2000, 0xc3d: 0x0024, 0xc3e: 0x0024, 0xc3f: 0x0010, // Block 0x31, offset 0xc40 0xc50: 0x0010, 0xc51: 0x0010, 0xc52: 0x0010, 0xc53: 0x0010, 0xc54: 0x0010, 0xc55: 0x0010, 0xc56: 0x2000, 0xc57: 0x2000, 0xc58: 0x0024, 0xc59: 0x0024, 0xc5a: 0x0010, 0xc5b: 0x0010, 0xc5c: 0x0010, 0xc5d: 0x0010, 0xc5e: 0x0024, 0xc5f: 0x0024, 0xc60: 0x0024, 0xc61: 0x0010, 0xc65: 0x0010, 0xc66: 0x0010, 0xc6e: 0x0010, 0xc6f: 0x0010, 0xc70: 0x0010, 0xc71: 0x0024, 0xc72: 0x0024, 0xc73: 0x0024, 0xc74: 0x0024, 0xc75: 0x0010, 0xc76: 0x0010, 0xc77: 0x0010, 0xc78: 0x0010, 0xc79: 0x0010, 0xc7a: 0x0010, 0xc7b: 0x0010, 0xc7c: 0x0010, 0xc7d: 0x0010, 0xc7e: 0x0010, 0xc7f: 0x0010, // Block 0x32, offset 0xc80 0xc80: 0x0010, 0xc81: 0x0010, 0xc82: 0x0024, 0xc84: 0x2000, 0xc85: 0x0024, 0xc86: 0x0024, 0xc8d: 0x0024, 0xc8e: 0x0010, 0xc9d: 0x0024, // Block 0x33, offset 0xcc0 0xcc0: 0x0080, 0xcc1: 0x0080, 0xcc2: 0x0080, 0xcc3: 0x0080, 0xcc4: 0x0080, 0xcc5: 0x0080, 0xcc6: 0x0080, 0xcc7: 0x0080, 0xcc8: 0x0080, 0xcc9: 0x0080, 0xcca: 0x0080, 0xccb: 0x0080, 0xccc: 0x0080, 0xccd: 0x0080, 0xcce: 0x0080, 0xccf: 0x0080, 0xcd0: 0x0080, 0xcd1: 0x0080, 0xcd2: 0x0080, 0xcd3: 0x0080, 0xcd4: 0x0080, 0xcd5: 0x0080, 0xcd6: 0x0080, 0xcd7: 0x0080, 0xcd8: 0x0080, 0xcd9: 0x0080, 0xcda: 0x0080, 0xcdb: 0x0080, 0xcdc: 0x0080, 0xcdd: 0x0080, 0xcde: 0x0080, 0xcdf: 0x0080, 0xce0: 0x0080, 0xce1: 0x0080, 0xce2: 0x0080, 0xce3: 0x0080, 0xce4: 0x0080, 0xce5: 0x0080, 0xce6: 0x0080, 0xce7: 0x0080, 0xce8: 0x0080, 0xce9: 0x0080, 0xcea: 0x0080, 0xceb: 0x0080, 0xcec: 0x0080, 0xced: 0x0080, 0xcee: 0x0080, 0xcef: 0x0080, 0xcf0: 0x0080, 0xcf1: 0x0080, 0xcf2: 0x0080, 0xcf3: 0x0080, 0xcf4: 0x0080, 0xcf5: 0x0080, 0xcf6: 0x0080, 0xcf7: 0x0080, 0xcf8: 0x0080, 0xcf9: 0x0080, 0xcfa: 0x0080, 0xcfb: 0x0080, 0xcfc: 0x0080, 0xcfd: 0x0080, 0xcfe: 0x0080, 0xcff: 0x0080, // Block 0x34, offset 0xd00 0xd00: 0x0080, 0xd01: 0x0080, 0xd02: 0x0080, 0xd03: 0x0080, 0xd04: 0x0080, 0xd05: 0x0080, 0xd06: 0x0080, 0xd07: 0x0080, 0xd08: 0x0080, 0xd09: 0x0080, 0xd0a: 0x0080, 0xd0b: 0x0080, 0xd0c: 0x0080, 0xd0d: 0x0080, 0xd0e: 0x0080, 0xd0f: 0x0080, 0xd10: 0x0080, 0xd11: 0x0080, 0xd12: 0x0080, 0xd13: 0x0080, 0xd14: 0x0080, 0xd15: 0x0080, 0xd16: 0x0080, 0xd17: 0x0080, 0xd18: 0x0080, 0xd19: 0x0080, 0xd1a: 0x0080, 0xd1b: 0x0080, 0xd1c: 0x0080, 0xd1d: 0x0080, 0xd1e: 0x0080, 0xd1f: 0x0080, 0xd20: 0x8000, 0xd21: 0x8000, 0xd22: 0x8000, 0xd23: 0x8000, 0xd24: 0x8000, 0xd25: 0x8000, 0xd26: 0x8000, 0xd27: 0x8000, 0xd28: 0x8000, 0xd29: 0x8000, 0xd2a: 0x8000, 0xd2b: 0x8000, 0xd2c: 0x8000, 0xd2d: 0x8000, 0xd2e: 0x8000, 0xd2f: 0x8000, 0xd30: 0x8000, 0xd31: 0x8000, 0xd32: 0x8000, 0xd33: 0x8000, 0xd34: 0x8000, 0xd35: 0x8000, 0xd36: 0x8000, 0xd37: 0x8000, 0xd38: 0x8000, 0xd39: 0x8000, 0xd3a: 0x8000, 0xd3b: 0x8000, 0xd3c: 0x8000, 0xd3d: 0x8000, 0xd3e: 0x8000, 0xd3f: 0x8000, // Block 0x35, offset 0xd40 0xd40: 0x8000, 0xd41: 0x8000, 0xd42: 0x8000, 0xd43: 0x8000, 0xd44: 0x8000, 0xd45: 0x8000, 0xd46: 0x8000, 0xd47: 0x8000, 0xd48: 0x8000, 0xd49: 0x8000, 0xd4a: 0x8000, 0xd4b: 0x8000, 0xd4c: 0x8000, 0xd4d: 0x8000, 0xd4e: 0x8000, 0xd4f: 0x8000, 0xd50: 0x8000, 0xd51: 0x8000, 0xd52: 0x8000, 0xd53: 0x8000, 0xd54: 0x8000, 0xd55: 0x8000, 0xd56: 0x8000, 0xd57: 0x8000, 0xd58: 0x8000, 0xd59: 0x8000, 0xd5a: 0x8000, 0xd5b: 0x8000, 0xd5c: 0x8000, 0xd5d: 0x8000, 0xd5e: 0x8000, 0xd5f: 0x8000, 0xd60: 0x8000, 0xd61: 0x8000, 0xd62: 0x8000, 0xd63: 0x8000, 0xd64: 0x8000, 0xd65: 0x8000, 0xd66: 0x8000, 0xd67: 0x8000, 0xd68: 0x4000, 0xd69: 0x4000, 0xd6a: 0x4000, 0xd6b: 0x4000, 0xd6c: 0x4000, 0xd6d: 0x4000, 0xd6e: 0x4000, 0xd6f: 0x4000, 0xd70: 0x4000, 0xd71: 0x4000, 0xd72: 0x4000, 0xd73: 0x4000, 0xd74: 0x4000, 0xd75: 0x4000, 0xd76: 0x4000, 0xd77: 0x4000, 0xd78: 0x4000, 0xd79: 0x4000, 0xd7a: 0x4000, 0xd7b: 0x4000, 0xd7c: 0x4000, 0xd7d: 0x4000, 0xd7e: 0x4000, 0xd7f: 0x4000, // Block 0x36, offset 0xd80 0xd80: 0x4000, 0xd81: 0x4000, 0xd82: 0x4000, 0xd83: 0x4000, 0xd84: 0x4000, 0xd85: 0x4000, 0xd86: 0x4000, 0xd87: 0x4000, 0xd88: 0x4000, 0xd89: 0x4000, 0xd8a: 0x4000, 0xd8b: 0x4000, 0xd8c: 0x4000, 0xd8d: 0x4000, 0xd8e: 0x4000, 0xd8f: 0x4000, 0xd90: 0x4000, 0xd91: 0x4000, 0xd92: 0x4000, 0xd93: 0x4000, 0xd94: 0x4000, 0xd95: 0x4000, 0xd96: 0x4000, 0xd97: 0x4000, 0xd98: 0x4000, 0xd99: 0x4000, 0xd9a: 0x4000, 0xd9b: 0x4000, 0xd9c: 0x4000, 0xd9d: 0x4000, 0xd9e: 0x4000, 0xd9f: 0x4000, 0xda0: 0x4000, 0xda1: 0x4000, 0xda2: 0x4000, 0xda3: 0x4000, 0xda4: 0x4000, 0xda5: 0x4000, 0xda6: 0x4000, 0xda7: 0x4000, 0xda8: 0x4000, 0xda9: 0x4000, 0xdaa: 0x4000, 0xdab: 0x4000, 0xdac: 0x4000, 0xdad: 0x4000, 0xdae: 0x4000, 0xdaf: 0x4000, 0xdb0: 0x4000, 0xdb1: 0x4000, 0xdb2: 0x4000, 0xdb3: 0x4000, 0xdb4: 0x4000, 0xdb5: 0x4000, 0xdb6: 0x4000, 0xdb7: 0x4000, 0xdb8: 0x4000, 0xdb9: 0x4000, 0xdba: 0x4000, 0xdbb: 0x4000, 0xdbc: 0x4000, 0xdbd: 0x4000, 0xdbe: 0x4000, 0xdbf: 0x4000, // Block 0x37, offset 0xdc0 0xddd: 0x0024, 0xdde: 0x0024, 0xddf: 0x0024, // Block 0x38, offset 0xe00 0xe12: 0x0024, 0xe13: 0x0024, 0xe14: 0x0024, 0xe15: 0x0024, 0xe32: 0x0024, 0xe33: 0x0024, 0xe34: 0x0024, // Block 0x39, offset 0xe40 0xe52: 0x0024, 0xe53: 0x0024, 0xe72: 0x0024, 0xe73: 0x0024, // Block 0x3a, offset 0xe80 0xe80: 0x0010, 0xe81: 0x0010, 0xe82: 0x0010, 0xe83: 0x0010, 0xe84: 0x0010, 0xe85: 0x0010, 0xe86: 0x0010, 0xe87: 0x0010, 0xe88: 0x0010, 0xe89: 0x0010, 0xe8a: 0x0010, 0xe8b: 0x0010, 0xe8c: 0x0010, 0xe8d: 0x0010, 0xe8e: 0x0010, 0xe8f: 0x0010, 0xe90: 0x0010, 0xe91: 0x0010, 0xe92: 0x0010, 0xe93: 0x0010, 0xe94: 0x0010, 0xe95: 0x0010, 0xe96: 0x0010, 0xe97: 0x0010, 0xe98: 0x0010, 0xe99: 0x0010, 0xe9a: 0x0010, 0xe9b: 0x0010, 0xe9c: 0x0010, 0xe9d: 0x0010, 0xe9e: 0x0010, 0xe9f: 0x0010, 0xea0: 0x0010, 0xea1: 0x0010, 0xea2: 0x0010, 0xea3: 0x0010, 0xea4: 0x0010, 0xea5: 0x0010, 0xea6: 0x0010, 0xea7: 0x0010, 0xea8: 0x0010, 0xea9: 0x0010, 0xeaa: 0x0010, 0xeab: 0x0010, 0xeac: 0x0010, 0xead: 0x0010, 0xeae: 0x0010, 0xeaf: 0x0010, 0xeb0: 0x0010, 0xeb1: 0x0010, 0xeb2: 0x0010, 0xeb3: 0x0010, 0xeb4: 0x0024, 0xeb5: 0x0024, 0xeb6: 0x2000, 0xeb7: 0x0024, 0xeb8: 0x0024, 0xeb9: 0x0024, 0xeba: 0x0024, 0xebb: 0x0024, 0xebc: 0x0024, 0xebd: 0x0024, 0xebe: 0x2000, 0xebf: 0x2000, // Block 0x3b, offset 0xec0 0xec0: 0x2000, 0xec1: 0x2000, 0xec2: 0x2000, 0xec3: 0x2000, 0xec4: 0x2000, 0xec5: 0x2000, 0xec6: 0x0024, 0xec7: 0x2000, 0xec8: 0x2000, 0xec9: 0x0024, 0xeca: 0x0024, 0xecb: 0x0024, 0xecc: 0x0024, 0xecd: 0x0024, 0xece: 0x0024, 0xecf: 0x0024, 0xed0: 0x0024, 0xed1: 0x0024, 0xed2: 0x0044, 0xed3: 0x0024, 0xedd: 0x0024, // Block 0x3c, offset 0xf00 0xf0b: 0x0024, 0xf0c: 0x0024, 0xf0d: 0x0024, 0xf0e: 0x0002, 0xf0f: 0x0024, // Block 0x3d, offset 0xf40 0xf45: 0x0024, 0xf46: 0x0024, 0xf69: 0x0024, // Block 0x3e, offset 0xf80 0xfa0: 0x0024, 0xfa1: 0x0024, 0xfa2: 0x0024, 0xfa3: 0x2000, 0xfa4: 0x2000, 0xfa5: 0x2000, 0xfa6: 0x2000, 0xfa7: 0x0024, 0xfa8: 0x0024, 0xfa9: 0x2000, 0xfaa: 0x2000, 0xfab: 0x2000, 0xfb0: 0x2000, 0xfb1: 0x2000, 0xfb2: 0x0024, 0xfb3: 0x2000, 0xfb4: 0x2000, 0xfb5: 0x2000, 0xfb6: 0x2000, 0xfb7: 0x2000, 0xfb8: 0x2000, 0xfb9: 0x0024, 0xfba: 0x0024, 0xfbb: 0x0024, // Block 0x3f, offset 0xfc0 0xfd7: 0x0024, 0xfd8: 0x0024, 0xfd9: 0x2000, 0xfda: 0x2000, 0xfdb: 0x0024, 0xfe0: 0x0010, 0xfe1: 0x0010, 0xfe2: 0x0010, 0xfe3: 0x0010, 0xfe4: 0x0010, 0xfe5: 0x0010, 0xfe6: 0x0010, 0xfe7: 0x0010, 0xfe8: 0x0010, 0xfe9: 0x0010, 0xfea: 0x0010, 0xfeb: 0x0010, 0xfec: 0x0010, 0xfed: 0x0010, 0xfee: 0x0010, 0xfef: 0x0010, 0xff0: 0x0010, 0xff1: 0x0010, 0xff2: 0x0010, 0xff3: 0x0010, 0xff4: 0x0010, 0xff5: 0x0010, 0xff6: 0x0010, 0xff7: 0x0010, 0xff8: 0x0010, 0xff9: 0x0010, 0xffa: 0x0010, 0xffb: 0x0010, 0xffc: 0x0010, 0xffd: 0x0010, 0xffe: 0x0010, 0xfff: 0x0010, // Block 0x40, offset 0x1000 0x1000: 0x0010, 0x1001: 0x0010, 0x1002: 0x0010, 0x1003: 0x0010, 0x1004: 0x0010, 0x1005: 0x0010, 0x1006: 0x0010, 0x1007: 0x0010, 0x1008: 0x0010, 0x1009: 0x0010, 0x100a: 0x0010, 0x100b: 0x0010, 0x100c: 0x0010, 0x100d: 0x0010, 0x100e: 0x0010, 0x100f: 0x0010, 0x1010: 0x0010, 0x1011: 0x0010, 0x1012: 0x0010, 0x1013: 0x0010, 0x1014: 0x0010, 0x1015: 0x2000, 0x1016: 0x0024, 0x1017: 0x2000, 0x1018: 0x0024, 0x1019: 0x0024, 0x101a: 0x0024, 0x101b: 0x0024, 0x101c: 0x0024, 0x101d: 0x0024, 0x101e: 0x0024, 0x1020: 0x0044, 0x1022: 0x0024, 0x1025: 0x0024, 0x1026: 0x0024, 0x1027: 0x0024, 0x1028: 0x0024, 0x1029: 0x0024, 0x102a: 0x0024, 0x102b: 0x0024, 0x102c: 0x0024, 0x102d: 0x2000, 0x102e: 0x2000, 0x102f: 0x2000, 0x1030: 0x2000, 0x1031: 0x2000, 0x1032: 0x2000, 0x1033: 0x0024, 0x1034: 0x0024, 0x1035: 0x0024, 0x1036: 0x0024, 0x1037: 0x0024, 0x1038: 0x0024, 0x1039: 0x0024, 0x103a: 0x0024, 0x103b: 0x0024, 0x103c: 0x0024, 0x103f: 0x0024, // Block 0x41, offset 0x1040 0x1070: 0x0024, 0x1071: 0x0024, 0x1072: 0x0024, 0x1073: 0x0024, 0x1074: 0x0024, 0x1075: 0x0024, 0x1076: 0x0024, 0x1077: 0x0024, 0x1078: 0x0024, 0x1079: 0x0024, 0x107a: 0x0024, 0x107b: 0x0024, 0x107c: 0x0024, 0x107d: 0x0024, 0x107e: 0x0024, 0x107f: 0x0024, // Block 0x42, offset 0x1080 0x1080: 0x0024, 0x1081: 0x0024, 0x1082: 0x0024, 0x1083: 0x0024, 0x1084: 0x0024, 0x1085: 0x0024, 0x1086: 0x0024, 0x1087: 0x0024, 0x1088: 0x0024, 0x1089: 0x0024, 0x108a: 0x0024, 0x108b: 0x0024, 0x108c: 0x0024, 0x108d: 0x0024, 0x108e: 0x0024, 0x108f: 0x0024, 0x1090: 0x0024, 0x1091: 0x0024, 0x1092: 0x0024, 0x1093: 0x0024, 0x1094: 0x0024, 0x1095: 0x0024, 0x1096: 0x0024, 0x1097: 0x0024, 0x1098: 0x0024, 0x1099: 0x0024, 0x109a: 0x0024, 0x109b: 0x0024, 0x109c: 0x0024, 0x109d: 0x0024, 0x10a0: 0x0024, 0x10a1: 0x0024, 0x10a2: 0x0024, 0x10a3: 0x0024, 0x10a4: 0x0024, 0x10a5: 0x0024, 0x10a6: 0x0024, 0x10a7: 0x0024, 0x10a8: 0x0024, 0x10a9: 0x0024, 0x10aa: 0x0024, 0x10ab: 0x0024, // Block 0x43, offset 0x10c0 0x10c0: 0x0024, 0x10c1: 0x0024, 0x10c2: 0x0024, 0x10c3: 0x0024, 0x10c4: 0x2000, 0x10cb: 0x0010, 0x10cc: 0x0010, 0x10d3: 0x0010, 0x10d4: 0x0010, 0x10d5: 0x0010, 0x10d6: 0x0010, 0x10d7: 0x0010, 0x10d8: 0x0010, 0x10d9: 0x0010, 0x10da: 0x0010, 0x10db: 0x0010, 0x10dc: 0x0010, 0x10dd: 0x0010, 0x10de: 0x0010, 0x10df: 0x0010, 0x10e0: 0x0010, 0x10e1: 0x0010, 0x10e2: 0x0010, 0x10e3: 0x0010, 0x10e4: 0x0010, 0x10e5: 0x0010, 0x10e6: 0x0010, 0x10e7: 0x0010, 0x10e8: 0x0010, 0x10e9: 0x0010, 0x10ea: 0x0010, 0x10eb: 0x0010, 0x10ec: 0x0010, 0x10ed: 0x0010, 0x10ee: 0x0010, 0x10ef: 0x0010, 0x10f0: 0x0010, 0x10f1: 0x0010, 0x10f2: 0x0010, 0x10f3: 0x0010, 0x10f4: 0x0024, 0x10f5: 0x0024, 0x10f6: 0x0024, 0x10f7: 0x0024, 0x10f8: 0x0024, 0x10f9: 0x0024, 0x10fa: 0x0024, 0x10fb: 0x0024, 0x10fc: 0x0024, 0x10fd: 0x0024, 0x10fe: 0x2000, 0x10ff: 0x2000, // Block 0x44, offset 0x1100 0x1100: 0x2000, 0x1101: 0x2000, 0x1102: 0x0024, 0x1103: 0x0024, 0x1104: 0x0044, 0x1105: 0x0010, 0x1106: 0x0010, 0x1107: 0x0010, 0x1108: 0x0010, 0x1109: 0x0010, 0x110a: 0x0010, 0x110b: 0x0010, 0x110c: 0x0010, 0x112b: 0x0024, 0x112c: 0x0024, 0x112d: 0x0024, 0x112e: 0x0024, 0x112f: 0x0024, 0x1130: 0x0024, 0x1131: 0x0024, 0x1132: 0x0024, 0x1133: 0x0024, // Block 0x45, offset 0x1140 0x1140: 0x0024, 0x1141: 0x0024, 0x1142: 0x2000, 0x1143: 0x0010, 0x1144: 0x0010, 0x1145: 0x0010, 0x1146: 0x0010, 0x1147: 0x0010, 0x1148: 0x0010, 0x1149: 0x0010, 0x114a: 0x0010, 0x114b: 0x0010, 0x114c: 0x0010, 0x114d: 0x0010, 0x114e: 0x0010, 0x114f: 0x0010, 0x1150: 0x0010, 0x1151: 0x0010, 0x1152: 0x0010, 0x1153: 0x0010, 0x1154: 0x0010, 0x1155: 0x0010, 0x1156: 0x0010, 0x1157: 0x0010, 0x1158: 0x0010, 0x1159: 0x0010, 0x115a: 0x0010, 0x115b: 0x0010, 0x115c: 0x0010, 0x115d: 0x0010, 0x115e: 0x0010, 0x115f: 0x0010, 0x1160: 0x0010, 0x1161: 0x2000, 0x1162: 0x0024, 0x1163: 0x0024, 0x1164: 0x0024, 0x1165: 0x0024, 0x1166: 0x2000, 0x1167: 0x2000, 0x1168: 0x0024, 0x1169: 0x0024, 0x116a: 0x0024, 0x116b: 0x0044, 0x116c: 0x0024, 0x116d: 0x0024, 0x116e: 0x0010, 0x116f: 0x0010, 0x117b: 0x0010, 0x117c: 0x0010, 0x117d: 0x0010, // Block 0x46, offset 0x1180 0x11a6: 0x0024, 0x11a7: 0x2000, 0x11a8: 0x0024, 0x11a9: 0x0024, 0x11aa: 0x2000, 0x11ab: 0x2000, 0x11ac: 0x2000, 0x11ad: 0x0024, 0x11ae: 0x2000, 0x11af: 0x0024, 0x11b0: 0x0024, 0x11b1: 0x0024, 0x11b2: 0x0024, 0x11b3: 0x0024, // Block 0x47, offset 0x11c0 0x11e4: 0x2000, 0x11e5: 0x2000, 0x11e6: 0x2000, 0x11e7: 0x2000, 0x11e8: 0x2000, 0x11e9: 0x2000, 0x11ea: 0x2000, 0x11eb: 0x2000, 0x11ec: 0x0024, 0x11ed: 0x0024, 0x11ee: 0x0024, 0x11ef: 0x0024, 0x11f0: 0x0024, 0x11f1: 0x0024, 0x11f2: 0x0024, 0x11f3: 0x0024, 0x11f4: 0x2000, 0x11f5: 0x2000, 0x11f6: 0x0024, 0x11f7: 0x0024, // Block 0x48, offset 0x1200 0x1210: 0x0024, 0x1211: 0x0024, 0x1212: 0x0024, 0x1214: 0x0024, 0x1215: 0x0024, 0x1216: 0x0024, 0x1217: 0x0024, 0x1218: 0x0024, 0x1219: 0x0024, 0x121a: 0x0024, 0x121b: 0x0024, 0x121c: 0x0024, 0x121d: 0x0024, 0x121e: 0x0024, 0x121f: 0x0024, 0x1220: 0x0024, 0x1221: 0x2000, 0x1222: 0x0024, 0x1223: 0x0024, 0x1224: 0x0024, 0x1225: 0x0024, 0x1226: 0x0024, 0x1227: 0x0024, 0x1228: 0x0024, 0x122d: 0x0024, 0x1234: 0x0024, 0x1237: 0x2000, 0x1238: 0x0024, 0x1239: 0x0024, // Block 0x49, offset 0x1240 0x124b: 0x0002, 0x124c: 0x0004, 0x124d: 0x10020, 0x124e: 0x0002, 0x124f: 0x0002, 0x1268: 0x0002, 0x1269: 0x0002, 0x126a: 0x0002, 0x126b: 0x0002, 0x126c: 0x0002, 0x126d: 0x0002, 0x126e: 0x0002, 0x127c: 0x0008, // Block 0x4a, offset 0x1280 0x1289: 0x0008, 0x12a0: 0x0002, 0x12a1: 0x0002, 0x12a2: 0x0002, 0x12a3: 0x0002, 0x12a4: 0x0002, 0x12a5: 0x0002, 0x12a6: 0x0002, 0x12a7: 0x0002, 0x12a8: 0x0002, 0x12a9: 0x0002, 0x12aa: 0x0002, 0x12ab: 0x0002, 0x12ac: 0x0002, 0x12ad: 0x0002, 0x12ae: 0x0002, 0x12af: 0x0002, // Block 0x4b, offset 0x12c0 0x12d0: 0x0024, 0x12d1: 0x0024, 0x12d2: 0x0024, 0x12d3: 0x0024, 0x12d4: 0x0024, 0x12d5: 0x0024, 0x12d6: 0x0024, 0x12d7: 0x0024, 0x12d8: 0x0024, 0x12d9: 0x0024, 0x12da: 0x0024, 0x12db: 0x0024, 0x12dc: 0x0024, 0x12dd: 0x0024, 0x12de: 0x0024, 0x12df: 0x0024, 0x12e0: 0x0024, 0x12e1: 0x0024, 0x12e2: 0x0024, 0x12e3: 0x0024, 0x12e4: 0x0024, 0x12e5: 0x0024, 0x12e6: 0x0024, 0x12e7: 0x0024, 0x12e8: 0x0024, 0x12e9: 0x0024, 0x12ea: 0x0024, 0x12eb: 0x0024, 0x12ec: 0x0024, 0x12ed: 0x0024, 0x12ee: 0x0024, 0x12ef: 0x0024, 0x12f0: 0x0024, // Block 0x4c, offset 0x1300 0x1322: 0x0008, 0x1339: 0x0008, // Block 0x4d, offset 0x1340 0x1354: 0x0008, 0x1355: 0x0008, 0x1356: 0x0008, 0x1357: 0x0008, 0x1358: 0x0008, 0x1359: 0x0008, 0x1369: 0x0008, 0x136a: 0x0008, // Block 0x4e, offset 0x1380 0x139a: 0x0008, 0x139b: 0x0008, 0x13a8: 0x0008, // Block 0x4f, offset 0x13c0 0x13cf: 0x0008, 0x13e9: 0x0008, 0x13ea: 0x0008, 0x13eb: 0x0008, 0x13ec: 0x0008, 0x13ed: 0x0008, 0x13ee: 0x0008, 0x13ef: 0x0008, 0x13f0: 0x0008, 0x13f1: 0x0008, 0x13f2: 0x0008, 0x13f3: 0x0008, 0x13f8: 0x0008, 0x13f9: 0x0008, 0x13fa: 0x0008, // Block 0x50, offset 0x1400 0x1402: 0x0008, // Block 0x51, offset 0x1440 0x146a: 0x0008, 0x146b: 0x0008, 0x1476: 0x0008, // Block 0x52, offset 0x1480 0x1480: 0x0008, 0x14bb: 0x0008, 0x14bc: 0x0008, 0x14bd: 0x0008, 0x14be: 0x0008, // Block 0x53, offset 0x14c0 0x14c0: 0x0008, 0x14c1: 0x0008, 0x14c2: 0x0008, 0x14c3: 0x0008, 0x14c4: 0x0008, 0x14ce: 0x0008, 0x14d1: 0x0008, 0x14d4: 0x0008, 0x14d5: 0x0008, 0x14d8: 0x0008, 0x14dd: 0x0008, 0x14e0: 0x0008, 0x14e2: 0x0008, 0x14e3: 0x0008, 0x14e6: 0x0008, 0x14ea: 0x0008, 0x14ee: 0x0008, 0x14ef: 0x0008, 0x14f8: 0x0008, 0x14f9: 0x0008, 0x14fa: 0x0008, // Block 0x54, offset 0x1500 0x1500: 0x0008, 0x1502: 0x0008, 0x1508: 0x0008, 0x1509: 0x0008, 0x150a: 0x0008, 0x150b: 0x0008, 0x150c: 0x0008, 0x150d: 0x0008, 0x150e: 0x0008, 0x150f: 0x0008, 0x1510: 0x0008, 0x1511: 0x0008, 0x1512: 0x0008, 0x1513: 0x0008, 0x151f: 0x0008, 0x1520: 0x0008, 0x1523: 0x0008, 0x1525: 0x0008, 0x1526: 0x0008, 0x1528: 0x0008, 0x153b: 0x0008, 0x153e: 0x0008, 0x153f: 0x0008, // Block 0x55, offset 0x1540 0x1552: 0x0008, 0x1553: 0x0008, 0x1554: 0x0008, 0x1555: 0x0008, 0x1556: 0x0008, 0x1557: 0x0008, 0x1559: 0x0008, 0x155b: 0x0008, 0x155c: 0x0008, 0x1560: 0x0008, 0x1561: 0x0008, 0x1567: 0x0008, 0x156a: 0x0008, 0x156b: 0x0008, 0x1570: 0x0008, 0x1571: 0x0008, 0x157d: 0x0008, 0x157e: 0x0008, // Block 0x56, offset 0x1580 0x1584: 0x0008, 0x1585: 0x0008, 0x1588: 0x0008, 0x158e: 0x0008, 0x158f: 0x0008, 0x1591: 0x0008, 0x1593: 0x0008, 0x1594: 0x0008, 0x15a9: 0x0008, 0x15aa: 0x0008, 0x15b0: 0x0008, 0x15b1: 0x0008, 0x15b2: 0x0008, 0x15b3: 0x0008, 0x15b4: 0x0008, 0x15b5: 0x0008, 0x15b7: 0x0008, 0x15b8: 0x0008, 0x15b9: 0x0008, 0x15ba: 0x0008, 0x15bd: 0x0008, // Block 0x57, offset 0x15c0 0x15c2: 0x0008, 0x15c5: 0x0008, 0x15c8: 0x0008, 0x15c9: 0x0008, 0x15ca: 0x0008, 0x15cb: 0x0008, 0x15cc: 0x0008, 0x15cd: 0x0008, 0x15cf: 0x0008, 0x15d2: 0x0008, 0x15d4: 0x0008, 0x15d6: 0x0008, 0x15dd: 0x0008, 0x15e1: 0x0008, 0x15e8: 0x0008, 0x15f3: 0x0008, 0x15f4: 0x0008, // Block 0x58, offset 0x1600 0x1604: 0x0008, 0x1607: 0x0008, 0x160c: 0x0008, 0x160e: 0x0008, 0x1613: 0x0008, 0x1614: 0x0008, 0x1615: 0x0008, 0x1617: 0x0008, 0x1623: 0x0008, 0x1624: 0x0008, // Block 0x59, offset 0x1640 0x1655: 0x0008, 0x1656: 0x0008, 0x1657: 0x0008, 0x1661: 0x0008, 0x1670: 0x0008, 0x167f: 0x0008, // Block 0x5a, offset 0x1680 0x16b4: 0x0008, 0x16b5: 0x0008, // Block 0x5b, offset 0x16c0 0x16c5: 0x0008, 0x16c6: 0x0008, 0x16c7: 0x0008, 0x16db: 0x0008, 0x16dc: 0x0008, // Block 0x5c, offset 0x1700 0x1710: 0x0008, 0x1715: 0x0008, // Block 0x5d, offset 0x1740 0x176f: 0x0024, 0x1770: 0x0024, 0x1771: 0x0024, // Block 0x5e, offset 0x1780 0x17bf: 0x0024, // Block 0x5f, offset 0x17c0 0x17e0: 0x0024, 0x17e1: 0x0024, 0x17e2: 0x0024, 0x17e3: 0x0024, 0x17e4: 0x0024, 0x17e5: 0x0024, 0x17e6: 0x0024, 0x17e7: 0x0024, 0x17e8: 0x0024, 0x17e9: 0x0024, 0x17ea: 0x0024, 0x17eb: 0x0024, 0x17ec: 0x0024, 0x17ed: 0x0024, 0x17ee: 0x0024, 0x17ef: 0x0024, 0x17f0: 0x0024, 0x17f1: 0x0024, 0x17f2: 0x0024, 0x17f3: 0x0024, 0x17f4: 0x0024, 0x17f5: 0x0024, 0x17f6: 0x0024, 0x17f7: 0x0024, 0x17f8: 0x0024, 0x17f9: 0x0024, 0x17fa: 0x0024, 0x17fb: 0x0024, 0x17fc: 0x0024, 0x17fd: 0x0024, 0x17fe: 0x0024, 0x17ff: 0x0024, // Block 0x60, offset 0x1800 0x182a: 0x0024, 0x182b: 0x0024, 0x182c: 0x0024, 0x182d: 0x0024, 0x182e: 0x0024, 0x182f: 0x0024, 0x1830: 0x0008, 0x183d: 0x0008, // Block 0x61, offset 0x1840 0x1859: 0x0024, 0x185a: 0x0024, // Block 0x62, offset 0x1880 0x1897: 0x0008, 0x1899: 0x0008, // Block 0x63, offset 0x18c0 0x18ef: 0x0024, 0x18f0: 0x0024, 0x18f1: 0x0024, 0x18f2: 0x0024, 0x18f4: 0x0024, 0x18f5: 0x0024, 0x18f6: 0x0024, 0x18f7: 0x0024, 0x18f8: 0x0024, 0x18f9: 0x0024, 0x18fa: 0x0024, 0x18fb: 0x0024, 0x18fc: 0x0024, 0x18fd: 0x0024, // Block 0x64, offset 0x1900 0x191e: 0x0024, 0x191f: 0x0024, // Block 0x65, offset 0x1940 0x1970: 0x0024, 0x1971: 0x0024, // Block 0x66, offset 0x1980 0x1982: 0x0024, 0x1986: 0x0024, 0x198b: 0x0024, 0x19a3: 0x2000, 0x19a4: 0x2000, 0x19a5: 0x0024, 0x19a6: 0x0024, 0x19a7: 0x2000, 0x19ac: 0x0024, // Block 0x67, offset 0x19c0 0x19c0: 0x2000, 0x19c1: 0x2000, 0x19f4: 0x2000, 0x19f5: 0x2000, 0x19f6: 0x2000, 0x19f7: 0x2000, 0x19f8: 0x2000, 0x19f9: 0x2000, 0x19fa: 0x2000, 0x19fb: 0x2000, 0x19fc: 0x2000, 0x19fd: 0x2000, 0x19fe: 0x2000, 0x19ff: 0x2000, // Block 0x68, offset 0x1a00 0x1a00: 0x2000, 0x1a01: 0x2000, 0x1a02: 0x2000, 0x1a03: 0x2000, 0x1a04: 0x0024, 0x1a05: 0x0024, 0x1a20: 0x0024, 0x1a21: 0x0024, 0x1a22: 0x0024, 0x1a23: 0x0024, 0x1a24: 0x0024, 0x1a25: 0x0024, 0x1a26: 0x0024, 0x1a27: 0x0024, 0x1a28: 0x0024, 0x1a29: 0x0024, 0x1a2a: 0x0024, 0x1a2b: 0x0024, 0x1a2c: 0x0024, 0x1a2d: 0x0024, 0x1a2e: 0x0024, 0x1a2f: 0x0024, 0x1a30: 0x0024, 0x1a31: 0x0024, 0x1a3f: 0x0024, // Block 0x69, offset 0x1a40 0x1a66: 0x0024, 0x1a67: 0x0024, 0x1a68: 0x0024, 0x1a69: 0x0024, 0x1a6a: 0x0024, 0x1a6b: 0x0024, 0x1a6c: 0x0024, 0x1a6d: 0x0024, // Block 0x6a, offset 0x1a80 0x1a87: 0x0024, 0x1a88: 0x0024, 0x1a89: 0x0024, 0x1a8a: 0x0024, 0x1a8b: 0x0024, 0x1a8c: 0x0024, 0x1a8d: 0x0024, 0x1a8e: 0x0024, 0x1a8f: 0x0024, 0x1a90: 0x0024, 0x1a91: 0x0024, 0x1a92: 0x2000, 0x1a93: 0x0024, 0x1aa0: 0x0080, 0x1aa1: 0x0080, 0x1aa2: 0x0080, 0x1aa3: 0x0080, 0x1aa4: 0x0080, 0x1aa5: 0x0080, 0x1aa6: 0x0080, 0x1aa7: 0x0080, 0x1aa8: 0x0080, 0x1aa9: 0x0080, 0x1aaa: 0x0080, 0x1aab: 0x0080, 0x1aac: 0x0080, 0x1aad: 0x0080, 0x1aae: 0x0080, 0x1aaf: 0x0080, 0x1ab0: 0x0080, 0x1ab1: 0x0080, 0x1ab2: 0x0080, 0x1ab3: 0x0080, 0x1ab4: 0x0080, 0x1ab5: 0x0080, 0x1ab6: 0x0080, 0x1ab7: 0x0080, 0x1ab8: 0x0080, 0x1ab9: 0x0080, 0x1aba: 0x0080, 0x1abb: 0x0080, 0x1abc: 0x0080, // Block 0x6b, offset 0x1ac0 0x1ac0: 0x0024, 0x1ac1: 0x0024, 0x1ac2: 0x0024, 0x1ac3: 0x2000, 0x1ac9: 0x0010, 0x1aca: 0x0010, 0x1acb: 0x0010, 0x1acf: 0x0010, 0x1ad0: 0x0010, 0x1ad1: 0x0010, 0x1ad2: 0x0010, 0x1ad3: 0x0010, 0x1ad4: 0x0010, 0x1ad5: 0x0010, 0x1ad6: 0x0010, 0x1ad7: 0x0010, 0x1ad8: 0x0010, 0x1ad9: 0x0010, 0x1ada: 0x0010, 0x1adb: 0x0010, 0x1adc: 0x0010, 0x1add: 0x0010, 0x1ade: 0x0010, 0x1adf: 0x0010, 0x1ae0: 0x0010, 0x1ae1: 0x0010, 0x1ae2: 0x0010, 0x1ae3: 0x0010, 0x1ae4: 0x0010, 0x1ae5: 0x0010, 0x1ae6: 0x0010, 0x1ae7: 0x0010, 0x1ae8: 0x0010, 0x1ae9: 0x0010, 0x1aea: 0x0010, 0x1aeb: 0x0010, 0x1aec: 0x0010, 0x1aed: 0x0010, 0x1aee: 0x0010, 0x1aef: 0x0010, 0x1af0: 0x0010, 0x1af1: 0x0010, 0x1af2: 0x0010, 0x1af3: 0x0024, 0x1af4: 0x2000, 0x1af5: 0x2000, 0x1af6: 0x0024, 0x1af7: 0x0024, 0x1af8: 0x0024, 0x1af9: 0x0024, 0x1afa: 0x2000, 0x1afb: 0x2000, 0x1afc: 0x0024, 0x1afd: 0x0024, 0x1afe: 0x2000, 0x1aff: 0x2000, // Block 0x6c, offset 0x1b00 0x1b00: 0x0044, 0x1b20: 0x0010, 0x1b21: 0x0010, 0x1b22: 0x0010, 0x1b23: 0x0010, 0x1b24: 0x0010, 0x1b25: 0x0024, 0x1b27: 0x0010, 0x1b28: 0x0010, 0x1b29: 0x0010, 0x1b2a: 0x0010, 0x1b2b: 0x0010, 0x1b2c: 0x0010, 0x1b2d: 0x0010, 0x1b2e: 0x0010, 0x1b2f: 0x0010, 0x1b3a: 0x0010, 0x1b3b: 0x0010, 0x1b3c: 0x0010, 0x1b3d: 0x0010, 0x1b3e: 0x0010, // Block 0x6d, offset 0x1b40 0x1b69: 0x0024, 0x1b6a: 0x0024, 0x1b6b: 0x0024, 0x1b6c: 0x0024, 0x1b6d: 0x0024, 0x1b6e: 0x0024, 0x1b6f: 0x2000, 0x1b70: 0x2000, 0x1b71: 0x0024, 0x1b72: 0x0024, 0x1b73: 0x2000, 0x1b74: 0x2000, 0x1b75: 0x0024, 0x1b76: 0x0024, // Block 0x6e, offset 0x1b80 0x1b83: 0x0024, 0x1b8c: 0x0024, 0x1b8d: 0x2000, 0x1ba0: 0x0010, 0x1ba1: 0x0010, 0x1ba2: 0x0010, 0x1ba3: 0x0010, 0x1ba4: 0x0010, 0x1ba5: 0x0010, 0x1ba6: 0x0010, 0x1ba7: 0x0010, 0x1ba8: 0x0010, 0x1ba9: 0x0010, 0x1baa: 0x0010, 0x1bab: 0x0010, 0x1bac: 0x0010, 0x1bad: 0x0010, 0x1bae: 0x0010, 0x1baf: 0x0010, 0x1bb1: 0x0010, 0x1bb2: 0x0010, 0x1bb3: 0x0010, 0x1bba: 0x0010, 0x1bbc: 0x0024, 0x1bbe: 0x0010, 0x1bbf: 0x0010, // Block 0x6f, offset 0x1bc0 0x1bf0: 0x0024, 0x1bf2: 0x0024, 0x1bf3: 0x0024, 0x1bf4: 0x0024, 0x1bf7: 0x0024, 0x1bf8: 0x0024, 0x1bfe: 0x0024, 0x1bff: 0x0024, // Block 0x70, offset 0x1c00 0x1c01: 0x0024, 0x1c20: 0x0010, 0x1c21: 0x0010, 0x1c22: 0x0010, 0x1c23: 0x0010, 0x1c24: 0x0010, 0x1c25: 0x0010, 0x1c26: 0x0010, 0x1c27: 0x0010, 0x1c28: 0x0010, 0x1c29: 0x0010, 0x1c2a: 0x0010, 0x1c2b: 0x2000, 0x1c2c: 0x0024, 0x1c2d: 0x0024, 0x1c2e: 0x2000, 0x1c2f: 0x2000, 0x1c35: 0x2000, 0x1c36: 0x0044, // Block 0x71, offset 0x1c40 0x1c40: 0x0010, 0x1c41: 0x0010, 0x1c42: 0x0010, 0x1c43: 0x0010, 0x1c44: 0x0010, 0x1c45: 0x0010, 0x1c46: 0x0010, 0x1c47: 0x0010, 0x1c48: 0x0010, 0x1c49: 0x0010, 0x1c4a: 0x0010, 0x1c4b: 0x0010, 0x1c4c: 0x0010, 0x1c4d: 0x0010, 0x1c4e: 0x0010, 0x1c4f: 0x0010, 0x1c50: 0x0010, 0x1c51: 0x0010, 0x1c52: 0x0010, 0x1c53: 0x0010, 0x1c54: 0x0010, 0x1c55: 0x0010, 0x1c56: 0x0010, 0x1c57: 0x0010, 0x1c58: 0x0010, 0x1c59: 0x0010, 0x1c5a: 0x0010, 0x1c63: 0x2000, 0x1c64: 0x2000, 0x1c65: 0x0024, 0x1c66: 0x2000, 0x1c67: 0x2000, 0x1c68: 0x0024, 0x1c69: 0x2000, 0x1c6a: 0x2000, 0x1c6c: 0x2000, 0x1c6d: 0x0024, // Block 0x72, offset 0x1c80 0x1c80: 0x0200, 0x1c81: 0x0400, 0x1c82: 0x0400, 0x1c83: 0x0400, 0x1c84: 0x0400, 0x1c85: 0x0400, 0x1c86: 0x0400, 0x1c87: 0x0400, 0x1c88: 0x0400, 0x1c89: 0x0400, 0x1c8a: 0x0400, 0x1c8b: 0x0400, 0x1c8c: 0x0400, 0x1c8d: 0x0400, 0x1c8e: 0x0400, 0x1c8f: 0x0400, 0x1c90: 0x0400, 0x1c91: 0x0400, 0x1c92: 0x0400, 0x1c93: 0x0400, 0x1c94: 0x0400, 0x1c95: 0x0400, 0x1c96: 0x0400, 0x1c97: 0x0400, 0x1c98: 0x0400, 0x1c99: 0x0400, 0x1c9a: 0x0400, 0x1c9b: 0x0400, 0x1c9c: 0x0200, 0x1c9d: 0x0400, 0x1c9e: 0x0400, 0x1c9f: 0x0400, 0x1ca0: 0x0400, 0x1ca1: 0x0400, 0x1ca2: 0x0400, 0x1ca3: 0x0400, 0x1ca4: 0x0400, 0x1ca5: 0x0400, 0x1ca6: 0x0400, 0x1ca7: 0x0400, 0x1ca8: 0x0400, 0x1ca9: 0x0400, 0x1caa: 0x0400, 0x1cab: 0x0400, 0x1cac: 0x0400, 0x1cad: 0x0400, 0x1cae: 0x0400, 0x1caf: 0x0400, 0x1cb0: 0x0400, 0x1cb1: 0x0400, 0x1cb2: 0x0400, 0x1cb3: 0x0400, 0x1cb4: 0x0400, 0x1cb5: 0x0400, 0x1cb6: 0x0400, 0x1cb7: 0x0400, 0x1cb8: 0x0200, 0x1cb9: 0x0400, 0x1cba: 0x0400, 0x1cbb: 0x0400, 0x1cbc: 0x0400, 0x1cbd: 0x0400, 0x1cbe: 0x0400, 0x1cbf: 0x0400, // Block 0x73, offset 0x1cc0 0x1cc0: 0x0400, 0x1cc1: 0x0400, 0x1cc2: 0x0400, 0x1cc3: 0x0400, 0x1cc4: 0x0400, 0x1cc5: 0x0400, 0x1cc6: 0x0400, 0x1cc7: 0x0400, 0x1cc8: 0x0400, 0x1cc9: 0x0400, 0x1cca: 0x0400, 0x1ccb: 0x0400, 0x1ccc: 0x0400, 0x1ccd: 0x0400, 0x1cce: 0x0400, 0x1ccf: 0x0400, 0x1cd0: 0x0400, 0x1cd1: 0x0400, 0x1cd2: 0x0400, 0x1cd3: 0x0400, 0x1cd4: 0x0200, 0x1cd5: 0x0400, 0x1cd6: 0x0400, 0x1cd7: 0x0400, 0x1cd8: 0x0400, 0x1cd9: 0x0400, 0x1cda: 0x0400, 0x1cdb: 0x0400, 0x1cdc: 0x0400, 0x1cdd: 0x0400, 0x1cde: 0x0400, 0x1cdf: 0x0400, 0x1ce0: 0x0400, 0x1ce1: 0x0400, 0x1ce2: 0x0400, 0x1ce3: 0x0400, 0x1ce4: 0x0400, 0x1ce5: 0x0400, 0x1ce6: 0x0400, 0x1ce7: 0x0400, 0x1ce8: 0x0400, 0x1ce9: 0x0400, 0x1cea: 0x0400, 0x1ceb: 0x0400, 0x1cec: 0x0400, 0x1ced: 0x0400, 0x1cee: 0x0400, 0x1cef: 0x0400, 0x1cf0: 0x0200, 0x1cf1: 0x0400, 0x1cf2: 0x0400, 0x1cf3: 0x0400, 0x1cf4: 0x0400, 0x1cf5: 0x0400, 0x1cf6: 0x0400, 0x1cf7: 0x0400, 0x1cf8: 0x0400, 0x1cf9: 0x0400, 0x1cfa: 0x0400, 0x1cfb: 0x0400, 0x1cfc: 0x0400, 0x1cfd: 0x0400, 0x1cfe: 0x0400, 0x1cff: 0x0400, // Block 0x74, offset 0x1d00 0x1d00: 0x0400, 0x1d01: 0x0400, 0x1d02: 0x0400, 0x1d03: 0x0400, 0x1d04: 0x0400, 0x1d05: 0x0400, 0x1d06: 0x0400, 0x1d07: 0x0400, 0x1d08: 0x0400, 0x1d09: 0x0400, 0x1d0a: 0x0400, 0x1d0b: 0x0400, 0x1d0c: 0x0200, 0x1d0d: 0x0400, 0x1d0e: 0x0400, 0x1d0f: 0x0400, 0x1d10: 0x0400, 0x1d11: 0x0400, 0x1d12: 0x0400, 0x1d13: 0x0400, 0x1d14: 0x0400, 0x1d15: 0x0400, 0x1d16: 0x0400, 0x1d17: 0x0400, 0x1d18: 0x0400, 0x1d19: 0x0400, 0x1d1a: 0x0400, 0x1d1b: 0x0400, 0x1d1c: 0x0400, 0x1d1d: 0x0400, 0x1d1e: 0x0400, 0x1d1f: 0x0400, 0x1d20: 0x0400, 0x1d21: 0x0400, 0x1d22: 0x0400, 0x1d23: 0x0400, 0x1d24: 0x0400, 0x1d25: 0x0400, 0x1d26: 0x0400, 0x1d27: 0x0400, 0x1d28: 0x0200, 0x1d29: 0x0400, 0x1d2a: 0x0400, 0x1d2b: 0x0400, 0x1d2c: 0x0400, 0x1d2d: 0x0400, 0x1d2e: 0x0400, 0x1d2f: 0x0400, 0x1d30: 0x0400, 0x1d31: 0x0400, 0x1d32: 0x0400, 0x1d33: 0x0400, 0x1d34: 0x0400, 0x1d35: 0x0400, 0x1d36: 0x0400, 0x1d37: 0x0400, 0x1d38: 0x0400, 0x1d39: 0x0400, 0x1d3a: 0x0400, 0x1d3b: 0x0400, 0x1d3c: 0x0400, 0x1d3d: 0x0400, 0x1d3e: 0x0400, 0x1d3f: 0x0400, // Block 0x75, offset 0x1d40 0x1d40: 0x0400, 0x1d41: 0x0400, 0x1d42: 0x0400, 0x1d43: 0x0400, 0x1d44: 0x0200, 0x1d45: 0x0400, 0x1d46: 0x0400, 0x1d47: 0x0400, 0x1d48: 0x0400, 0x1d49: 0x0400, 0x1d4a: 0x0400, 0x1d4b: 0x0400, 0x1d4c: 0x0400, 0x1d4d: 0x0400, 0x1d4e: 0x0400, 0x1d4f: 0x0400, 0x1d50: 0x0400, 0x1d51: 0x0400, 0x1d52: 0x0400, 0x1d53: 0x0400, 0x1d54: 0x0400, 0x1d55: 0x0400, 0x1d56: 0x0400, 0x1d57: 0x0400, 0x1d58: 0x0400, 0x1d59: 0x0400, 0x1d5a: 0x0400, 0x1d5b: 0x0400, 0x1d5c: 0x0400, 0x1d5d: 0x0400, 0x1d5e: 0x0400, 0x1d5f: 0x0400, 0x1d60: 0x0200, 0x1d61: 0x0400, 0x1d62: 0x0400, 0x1d63: 0x0400, 0x1d64: 0x0400, 0x1d65: 0x0400, 0x1d66: 0x0400, 0x1d67: 0x0400, 0x1d68: 0x0400, 0x1d69: 0x0400, 0x1d6a: 0x0400, 0x1d6b: 0x0400, 0x1d6c: 0x0400, 0x1d6d: 0x0400, 0x1d6e: 0x0400, 0x1d6f: 0x0400, 0x1d70: 0x0400, 0x1d71: 0x0400, 0x1d72: 0x0400, 0x1d73: 0x0400, 0x1d74: 0x0400, 0x1d75: 0x0400, 0x1d76: 0x0400, 0x1d77: 0x0400, 0x1d78: 0x0400, 0x1d79: 0x0400, 0x1d7a: 0x0400, 0x1d7b: 0x0400, 0x1d7c: 0x0200, 0x1d7d: 0x0400, 0x1d7e: 0x0400, 0x1d7f: 0x0400, // Block 0x76, offset 0x1d80 0x1d80: 0x0400, 0x1d81: 0x0400, 0x1d82: 0x0400, 0x1d83: 0x0400, 0x1d84: 0x0400, 0x1d85: 0x0400, 0x1d86: 0x0400, 0x1d87: 0x0400, 0x1d88: 0x0400, 0x1d89: 0x0400, 0x1d8a: 0x0400, 0x1d8b: 0x0400, 0x1d8c: 0x0400, 0x1d8d: 0x0400, 0x1d8e: 0x0400, 0x1d8f: 0x0400, 0x1d90: 0x0400, 0x1d91: 0x0400, 0x1d92: 0x0400, 0x1d93: 0x0400, 0x1d94: 0x0400, 0x1d95: 0x0400, 0x1d96: 0x0400, 0x1d97: 0x0400, 0x1d98: 0x0200, 0x1d99: 0x0400, 0x1d9a: 0x0400, 0x1d9b: 0x0400, 0x1d9c: 0x0400, 0x1d9d: 0x0400, 0x1d9e: 0x0400, 0x1d9f: 0x0400, 0x1da0: 0x0400, 0x1da1: 0x0400, 0x1da2: 0x0400, 0x1da3: 0x0400, 0x1da4: 0x0400, 0x1da5: 0x0400, 0x1da6: 0x0400, 0x1da7: 0x0400, 0x1da8: 0x0400, 0x1da9: 0x0400, 0x1daa: 0x0400, 0x1dab: 0x0400, 0x1dac: 0x0400, 0x1dad: 0x0400, 0x1dae: 0x0400, 0x1daf: 0x0400, 0x1db0: 0x0400, 0x1db1: 0x0400, 0x1db2: 0x0400, 0x1db3: 0x0400, 0x1db4: 0x0200, 0x1db5: 0x0400, 0x1db6: 0x0400, 0x1db7: 0x0400, 0x1db8: 0x0400, 0x1db9: 0x0400, 0x1dba: 0x0400, 0x1dbb: 0x0400, 0x1dbc: 0x0400, 0x1dbd: 0x0400, 0x1dbe: 0x0400, 0x1dbf: 0x0400, // Block 0x77, offset 0x1dc0 0x1dc0: 0x0400, 0x1dc1: 0x0400, 0x1dc2: 0x0400, 0x1dc3: 0x0400, 0x1dc4: 0x0400, 0x1dc5: 0x0400, 0x1dc6: 0x0400, 0x1dc7: 0x0400, 0x1dc8: 0x0400, 0x1dc9: 0x0400, 0x1dca: 0x0400, 0x1dcb: 0x0400, 0x1dcc: 0x0400, 0x1dcd: 0x0400, 0x1dce: 0x0400, 0x1dcf: 0x0400, 0x1dd0: 0x0200, 0x1dd1: 0x0400, 0x1dd2: 0x0400, 0x1dd3: 0x0400, 0x1dd4: 0x0400, 0x1dd5: 0x0400, 0x1dd6: 0x0400, 0x1dd7: 0x0400, 0x1dd8: 0x0400, 0x1dd9: 0x0400, 0x1dda: 0x0400, 0x1ddb: 0x0400, 0x1ddc: 0x0400, 0x1ddd: 0x0400, 0x1dde: 0x0400, 0x1ddf: 0x0400, 0x1de0: 0x0400, 0x1de1: 0x0400, 0x1de2: 0x0400, 0x1de3: 0x0400, 0x1de4: 0x0400, 0x1de5: 0x0400, 0x1de6: 0x0400, 0x1de7: 0x0400, 0x1de8: 0x0400, 0x1de9: 0x0400, 0x1dea: 0x0400, 0x1deb: 0x0400, 0x1dec: 0x0200, 0x1ded: 0x0400, 0x1dee: 0x0400, 0x1def: 0x0400, 0x1df0: 0x0400, 0x1df1: 0x0400, 0x1df2: 0x0400, 0x1df3: 0x0400, 0x1df4: 0x0400, 0x1df5: 0x0400, 0x1df6: 0x0400, 0x1df7: 0x0400, 0x1df8: 0x0400, 0x1df9: 0x0400, 0x1dfa: 0x0400, 0x1dfb: 0x0400, 0x1dfc: 0x0400, 0x1dfd: 0x0400, 0x1dfe: 0x0400, 0x1dff: 0x0400, // Block 0x78, offset 0x1e00 0x1e00: 0x0400, 0x1e01: 0x0400, 0x1e02: 0x0400, 0x1e03: 0x0400, 0x1e04: 0x0400, 0x1e05: 0x0400, 0x1e06: 0x0400, 0x1e07: 0x0400, 0x1e08: 0x0200, 0x1e09: 0x0400, 0x1e0a: 0x0400, 0x1e0b: 0x0400, 0x1e0c: 0x0400, 0x1e0d: 0x0400, 0x1e0e: 0x0400, 0x1e0f: 0x0400, 0x1e10: 0x0400, 0x1e11: 0x0400, 0x1e12: 0x0400, 0x1e13: 0x0400, 0x1e14: 0x0400, 0x1e15: 0x0400, 0x1e16: 0x0400, 0x1e17: 0x0400, 0x1e18: 0x0400, 0x1e19: 0x0400, 0x1e1a: 0x0400, 0x1e1b: 0x0400, 0x1e1c: 0x0400, 0x1e1d: 0x0400, 0x1e1e: 0x0400, 0x1e1f: 0x0400, 0x1e20: 0x0400, 0x1e21: 0x0400, 0x1e22: 0x0400, 0x1e23: 0x0400, 0x1e24: 0x0200, 0x1e25: 0x0400, 0x1e26: 0x0400, 0x1e27: 0x0400, 0x1e28: 0x0400, 0x1e29: 0x0400, 0x1e2a: 0x0400, 0x1e2b: 0x0400, 0x1e2c: 0x0400, 0x1e2d: 0x0400, 0x1e2e: 0x0400, 0x1e2f: 0x0400, 0x1e30: 0x0400, 0x1e31: 0x0400, 0x1e32: 0x0400, 0x1e33: 0x0400, 0x1e34: 0x0400, 0x1e35: 0x0400, 0x1e36: 0x0400, 0x1e37: 0x0400, 0x1e38: 0x0400, 0x1e39: 0x0400, 0x1e3a: 0x0400, 0x1e3b: 0x0400, 0x1e3c: 0x0400, 0x1e3d: 0x0400, 0x1e3e: 0x0400, 0x1e3f: 0x0400, // Block 0x79, offset 0x1e40 0x1e40: 0x0400, 0x1e41: 0x0400, 0x1e42: 0x0400, 0x1e43: 0x0400, 0x1e44: 0x0400, 0x1e45: 0x0400, 0x1e46: 0x0400, 0x1e47: 0x0400, 0x1e48: 0x0200, 0x1e49: 0x0400, 0x1e4a: 0x0400, 0x1e4b: 0x0400, 0x1e4c: 0x0400, 0x1e4d: 0x0400, 0x1e4e: 0x0400, 0x1e4f: 0x0400, 0x1e50: 0x0400, 0x1e51: 0x0400, 0x1e52: 0x0400, 0x1e53: 0x0400, 0x1e54: 0x0400, 0x1e55: 0x0400, 0x1e56: 0x0400, 0x1e57: 0x0400, 0x1e58: 0x0400, 0x1e59: 0x0400, 0x1e5a: 0x0400, 0x1e5b: 0x0400, 0x1e5c: 0x0400, 0x1e5d: 0x0400, 0x1e5e: 0x0400, 0x1e5f: 0x0400, 0x1e60: 0x0400, 0x1e61: 0x0400, 0x1e62: 0x0400, 0x1e63: 0x0400, 0x1e70: 0x8000, 0x1e71: 0x8000, 0x1e72: 0x8000, 0x1e73: 0x8000, 0x1e74: 0x8000, 0x1e75: 0x8000, 0x1e76: 0x8000, 0x1e77: 0x8000, 0x1e78: 0x8000, 0x1e79: 0x8000, 0x1e7a: 0x8000, 0x1e7b: 0x8000, 0x1e7c: 0x8000, 0x1e7d: 0x8000, 0x1e7e: 0x8000, 0x1e7f: 0x8000, // Block 0x7a, offset 0x1e80 0x1e80: 0x8000, 0x1e81: 0x8000, 0x1e82: 0x8000, 0x1e83: 0x8000, 0x1e84: 0x8000, 0x1e85: 0x8000, 0x1e86: 0x8000, 0x1e8b: 0x4000, 0x1e8c: 0x4000, 0x1e8d: 0x4000, 0x1e8e: 0x4000, 0x1e8f: 0x4000, 0x1e90: 0x4000, 0x1e91: 0x4000, 0x1e92: 0x4000, 0x1e93: 0x4000, 0x1e94: 0x4000, 0x1e95: 0x4000, 0x1e96: 0x4000, 0x1e97: 0x4000, 0x1e98: 0x4000, 0x1e99: 0x4000, 0x1e9a: 0x4000, 0x1e9b: 0x4000, 0x1e9c: 0x4000, 0x1e9d: 0x4000, 0x1e9e: 0x4000, 0x1e9f: 0x4000, 0x1ea0: 0x4000, 0x1ea1: 0x4000, 0x1ea2: 0x4000, 0x1ea3: 0x4000, 0x1ea4: 0x4000, 0x1ea5: 0x4000, 0x1ea6: 0x4000, 0x1ea7: 0x4000, 0x1ea8: 0x4000, 0x1ea9: 0x4000, 0x1eaa: 0x4000, 0x1eab: 0x4000, 0x1eac: 0x4000, 0x1ead: 0x4000, 0x1eae: 0x4000, 0x1eaf: 0x4000, 0x1eb0: 0x4000, 0x1eb1: 0x4000, 0x1eb2: 0x4000, 0x1eb3: 0x4000, 0x1eb4: 0x4000, 0x1eb5: 0x4000, 0x1eb6: 0x4000, 0x1eb7: 0x4000, 0x1eb8: 0x4000, 0x1eb9: 0x4000, 0x1eba: 0x4000, 0x1ebb: 0x4000, // Block 0x7b, offset 0x1ec0 0x1ede: 0x0024, // Block 0x7c, offset 0x1f00 0x1f00: 0x0024, 0x1f01: 0x0024, 0x1f02: 0x0024, 0x1f03: 0x0024, 0x1f04: 0x0024, 0x1f05: 0x0024, 0x1f06: 0x0024, 0x1f07: 0x0024, 0x1f08: 0x0024, 0x1f09: 0x0024, 0x1f0a: 0x0024, 0x1f0b: 0x0024, 0x1f0c: 0x0024, 0x1f0d: 0x0024, 0x1f0e: 0x0024, 0x1f0f: 0x0024, 0x1f20: 0x0024, 0x1f21: 0x0024, 0x1f22: 0x0024, 0x1f23: 0x0024, 0x1f24: 0x0024, 0x1f25: 0x0024, 0x1f26: 0x0024, 0x1f27: 0x0024, 0x1f28: 0x0024, 0x1f29: 0x0024, 0x1f2a: 0x0024, 0x1f2b: 0x0024, 0x1f2c: 0x0024, 0x1f2d: 0x0024, 0x1f2e: 0x0024, 0x1f2f: 0x0024, // Block 0x7d, offset 0x1f40 0x1f7f: 0x0002, // Block 0x7e, offset 0x1f80 0x1fb0: 0x0002, 0x1fb1: 0x0002, 0x1fb2: 0x0002, 0x1fb3: 0x0002, 0x1fb4: 0x0002, 0x1fb5: 0x0002, 0x1fb6: 0x0002, 0x1fb7: 0x0002, 0x1fb8: 0x0002, 0x1fb9: 0x0002, 0x1fba: 0x0002, 0x1fbb: 0x0002, // Block 0x7f, offset 0x1fc0 0x1ffd: 0x0024, // Block 0x80, offset 0x2000 0x2020: 0x0024, // Block 0x81, offset 0x2040 0x2076: 0x0024, 0x2077: 0x0024, 0x2078: 0x0024, 0x2079: 0x0024, 0x207a: 0x0024, // Block 0x82, offset 0x2080 0x2080: 0x0010, 0x2081: 0x0024, 0x2082: 0x0024, 0x2083: 0x0024, 0x2085: 0x0024, 0x2086: 0x0024, 0x208c: 0x0024, 0x208d: 0x0024, 0x208e: 0x0024, 0x208f: 0x0024, 0x2090: 0x0010, 0x2091: 0x0010, 0x2092: 0x0010, 0x2093: 0x0010, 0x2095: 0x0010, 0x2096: 0x0010, 0x2097: 0x0010, 0x2099: 0x0010, 0x209a: 0x0010, 0x209b: 0x0010, 0x209c: 0x0010, 0x209d: 0x0010, 0x209e: 0x0010, 0x209f: 0x0010, 0x20a0: 0x0010, 0x20a1: 0x0010, 0x20a2: 0x0010, 0x20a3: 0x0010, 0x20a4: 0x0010, 0x20a5: 0x0010, 0x20a6: 0x0010, 0x20a7: 0x0010, 0x20a8: 0x0010, 0x20a9: 0x0010, 0x20aa: 0x0010, 0x20ab: 0x0010, 0x20ac: 0x0010, 0x20ad: 0x0010, 0x20ae: 0x0010, 0x20af: 0x0010, 0x20b0: 0x0010, 0x20b1: 0x0010, 0x20b2: 0x0010, 0x20b3: 0x0010, 0x20b4: 0x0010, 0x20b5: 0x0010, 0x20b8: 0x0024, 0x20b9: 0x0024, 0x20ba: 0x0024, 0x20bf: 0x0044, // Block 0x83, offset 0x20c0 0x20e5: 0x0024, 0x20e6: 0x0024, // Block 0x84, offset 0x2100 0x2124: 0x0024, 0x2125: 0x0024, 0x2126: 0x0024, 0x2127: 0x0024, // Block 0x85, offset 0x2140 0x2169: 0x0024, 0x216a: 0x0024, 0x216b: 0x0024, 0x216c: 0x0024, 0x216d: 0x0024, // Block 0x86, offset 0x2180 0x21ab: 0x0024, 0x21ac: 0x0024, // Block 0x87, offset 0x21c0 0x21fa: 0x0024, 0x21fb: 0x0024, 0x21fc: 0x0024, 0x21fd: 0x0024, 0x21fe: 0x0024, 0x21ff: 0x0024, // Block 0x88, offset 0x2200 0x2206: 0x0024, 0x2207: 0x0024, 0x2208: 0x0024, 0x2209: 0x0024, 0x220a: 0x0024, 0x220b: 0x0024, 0x220c: 0x0024, 0x220d: 0x0024, 0x220e: 0x0024, 0x220f: 0x0024, 0x2210: 0x0024, // Block 0x89, offset 0x2240 0x2242: 0x0024, 0x2243: 0x0024, 0x2244: 0x0024, 0x2245: 0x0024, // Block 0x8a, offset 0x2280 0x2280: 0x2000, 0x2281: 0x0024, 0x2282: 0x2000, 0x22b8: 0x0024, 0x22b9: 0x0024, 0x22ba: 0x0024, 0x22bb: 0x0024, 0x22bc: 0x0024, 0x22bd: 0x0024, 0x22be: 0x0024, 0x22bf: 0x0024, // Block 0x8b, offset 0x22c0 0x22c0: 0x0024, 0x22c1: 0x0024, 0x22c2: 0x0024, 0x22c3: 0x0024, 0x22c4: 0x0024, 0x22c5: 0x0024, 0x22c6: 0x0024, 0x22f0: 0x0024, 0x22f3: 0x0024, 0x22f4: 0x0024, 0x22ff: 0x0024, // Block 0x8c, offset 0x2300 0x2300: 0x0024, 0x2301: 0x0024, 0x2302: 0x2000, 0x2330: 0x2000, 0x2331: 0x2000, 0x2332: 0x2000, 0x2333: 0x0024, 0x2334: 0x0024, 0x2335: 0x0024, 0x2336: 0x0024, 0x2337: 0x2000, 0x2338: 0x2000, 0x2339: 0x0024, 0x233a: 0x0024, 0x233d: 0x0800, // Block 0x8d, offset 0x2340 0x2342: 0x0024, 0x234d: 0x0800, // Block 0x8e, offset 0x2380 0x2380: 0x0024, 0x2381: 0x0024, 0x2382: 0x0024, 0x2383: 0x0010, 0x2384: 0x0010, 0x2385: 0x0010, 0x2386: 0x0010, 0x2387: 0x0010, 0x2388: 0x0010, 0x2389: 0x0010, 0x238a: 0x0010, 0x238b: 0x0010, 0x238c: 0x0010, 0x238d: 0x0010, 0x238e: 0x0010, 0x238f: 0x0010, 0x2390: 0x0010, 0x2391: 0x0010, 0x2392: 0x0010, 0x2393: 0x0010, 0x2394: 0x0010, 0x2395: 0x0010, 0x2396: 0x0010, 0x2397: 0x0010, 0x2398: 0x0010, 0x2399: 0x0010, 0x239a: 0x0010, 0x239b: 0x0010, 0x239c: 0x0010, 0x239d: 0x0010, 0x239e: 0x0010, 0x239f: 0x0010, 0x23a0: 0x0010, 0x23a1: 0x0010, 0x23a2: 0x0010, 0x23a3: 0x0010, 0x23a4: 0x0010, 0x23a5: 0x0010, 0x23a6: 0x0010, 0x23a7: 0x0024, 0x23a8: 0x0024, 0x23a9: 0x0024, 0x23aa: 0x0024, 0x23ab: 0x0024, 0x23ac: 0x2000, 0x23ad: 0x0024, 0x23ae: 0x0024, 0x23af: 0x0024, 0x23b0: 0x0024, 0x23b1: 0x0024, 0x23b2: 0x0024, 0x23b3: 0x0044, 0x23b4: 0x0024, // Block 0x8f, offset 0x23c0 0x23c4: 0x0010, 0x23c5: 0x2000, 0x23c6: 0x2000, 0x23c7: 0x0010, 0x23f3: 0x0024, // Block 0x90, offset 0x2400 0x2400: 0x0024, 0x2401: 0x0024, 0x2402: 0x2000, 0x2433: 0x2000, 0x2434: 0x2000, 0x2435: 0x2000, 0x2436: 0x0024, 0x2437: 0x0024, 0x2438: 0x0024, 0x2439: 0x0024, 0x243a: 0x0024, 0x243b: 0x0024, 0x243c: 0x0024, 0x243d: 0x0024, 0x243e: 0x0024, 0x243f: 0x2000, // Block 0x91, offset 0x2440 0x2440: 0x0024, 0x2442: 0x0800, 0x2443: 0x0800, 0x2449: 0x0024, 0x244a: 0x0024, 0x244b: 0x0024, 0x244c: 0x0024, 0x244e: 0x2000, 0x244f: 0x0024, // Block 0x92, offset 0x2480 0x24ac: 0x2000, 0x24ad: 0x2000, 0x24ae: 0x2000, 0x24af: 0x0024, 0x24b0: 0x0024, 0x24b1: 0x0024, 0x24b2: 0x2000, 0x24b3: 0x2000, 0x24b4: 0x0024, 0x24b5: 0x0024, 0x24b6: 0x0024, 0x24b7: 0x0024, 0x24be: 0x0024, // Block 0x93, offset 0x24c0 0x24c1: 0x0024, // Block 0x94, offset 0x2500 0x251f: 0x0024, 0x2520: 0x2000, 0x2521: 0x2000, 0x2522: 0x2000, 0x2523: 0x0024, 0x2524: 0x0024, 0x2525: 0x0024, 0x2526: 0x0024, 0x2527: 0x0024, 0x2528: 0x0024, 0x2529: 0x0024, 0x252a: 0x0024, // Block 0x95, offset 0x2540 0x2540: 0x0024, 0x2541: 0x0024, 0x2542: 0x2000, 0x2543: 0x2000, 0x257b: 0x0024, 0x257c: 0x0024, 0x257e: 0x0024, 0x257f: 0x2000, // Block 0x96, offset 0x2580 0x2580: 0x0024, 0x2581: 0x2000, 0x2582: 0x2000, 0x2583: 0x2000, 0x2584: 0x2000, 0x2587: 0x2000, 0x2588: 0x2000, 0x258b: 0x2000, 0x258c: 0x2000, 0x258d: 0x0024, 0x2597: 0x0024, 0x25a2: 0x2000, 0x25a3: 0x2000, 0x25a6: 0x0024, 0x25a7: 0x0024, 0x25a8: 0x0024, 0x25a9: 0x0024, 0x25aa: 0x0024, 0x25ab: 0x0024, 0x25ac: 0x0024, 0x25b0: 0x0024, 0x25b1: 0x0024, 0x25b2: 0x0024, 0x25b3: 0x0024, 0x25b4: 0x0024, // Block 0x97, offset 0x25c0 0x25c0: 0x0010, 0x25c1: 0x0010, 0x25c2: 0x0010, 0x25c3: 0x0010, 0x25c4: 0x0010, 0x25c5: 0x0010, 0x25c6: 0x0010, 0x25c7: 0x0010, 0x25c8: 0x0010, 0x25c9: 0x0010, 0x25cb: 0x0010, 0x25ce: 0x0010, 0x25d0: 0x0010, 0x25d1: 0x0010, 0x25d2: 0x0010, 0x25d3: 0x0010, 0x25d4: 0x0010, 0x25d5: 0x0010, 0x25d6: 0x0010, 0x25d7: 0x0010, 0x25d8: 0x0010, 0x25d9: 0x0010, 0x25da: 0x0010, 0x25db: 0x0010, 0x25dc: 0x0010, 0x25dd: 0x0010, 0x25de: 0x0010, 0x25df: 0x0010, 0x25e0: 0x0010, 0x25e1: 0x0010, 0x25e2: 0x0010, 0x25e3: 0x0010, 0x25e4: 0x0010, 0x25e5: 0x0010, 0x25e6: 0x0010, 0x25e7: 0x0010, 0x25e8: 0x0010, 0x25e9: 0x0010, 0x25ea: 0x0010, 0x25eb: 0x0010, 0x25ec: 0x0010, 0x25ed: 0x0010, 0x25ee: 0x0010, 0x25ef: 0x0010, 0x25f0: 0x0010, 0x25f1: 0x0010, 0x25f2: 0x0010, 0x25f3: 0x0010, 0x25f4: 0x0010, 0x25f5: 0x0010, 0x25f8: 0x0024, 0x25f9: 0x2000, 0x25fa: 0x2000, 0x25fb: 0x0024, 0x25fc: 0x0024, 0x25fd: 0x0024, 0x25fe: 0x0024, 0x25ff: 0x0024, // Block 0x98, offset 0x2600 0x2600: 0x0024, 0x2602: 0x0024, 0x2605: 0x0024, 0x2607: 0x0024, 0x2608: 0x0024, 0x2609: 0x0024, 0x260a: 0x2000, 0x260c: 0x2000, 0x260d: 0x2000, 0x260e: 0x0024, 0x260f: 0x0024, 0x2610: 0x0044, 0x2611: 0x0800, 0x2612: 0x0024, 0x2621: 0x0024, 0x2622: 0x0024, // Block 0x99, offset 0x2640 0x2675: 0x2000, 0x2676: 0x2000, 0x2677: 0x2000, 0x2678: 0x0024, 0x2679: 0x0024, 0x267a: 0x0024, 0x267b: 0x0024, 0x267c: 0x0024, 0x267d: 0x0024, 0x267e: 0x0024, 0x267f: 0x0024, // Block 0x9a, offset 0x2680 0x2680: 0x2000, 0x2681: 0x2000, 0x2682: 0x0024, 0x2683: 0x0024, 0x2684: 0x0024, 0x2685: 0x2000, 0x2686: 0x0024, 0x269e: 0x0024, // Block 0x9b, offset 0x26c0 0x26f0: 0x0024, 0x26f1: 0x2000, 0x26f2: 0x2000, 0x26f3: 0x0024, 0x26f4: 0x0024, 0x26f5: 0x0024, 0x26f6: 0x0024, 0x26f7: 0x0024, 0x26f8: 0x0024, 0x26f9: 0x2000, 0x26fa: 0x0024, 0x26fb: 0x2000, 0x26fc: 0x2000, 0x26fd: 0x0024, 0x26fe: 0x2000, 0x26ff: 0x0024, // Block 0x9c, offset 0x2700 0x2700: 0x0024, 0x2701: 0x2000, 0x2702: 0x0024, 0x2703: 0x0024, // Block 0x9d, offset 0x2740 0x276f: 0x0024, 0x2770: 0x2000, 0x2771: 0x2000, 0x2772: 0x0024, 0x2773: 0x0024, 0x2774: 0x0024, 0x2775: 0x0024, 0x2778: 0x2000, 0x2779: 0x2000, 0x277a: 0x2000, 0x277b: 0x2000, 0x277c: 0x0024, 0x277d: 0x0024, 0x277e: 0x2000, 0x277f: 0x0024, // Block 0x9e, offset 0x2780 0x2780: 0x0024, 0x279c: 0x0024, 0x279d: 0x0024, // Block 0x9f, offset 0x27c0 0x27f0: 0x2000, 0x27f1: 0x2000, 0x27f2: 0x2000, 0x27f3: 0x0024, 0x27f4: 0x0024, 0x27f5: 0x0024, 0x27f6: 0x0024, 0x27f7: 0x0024, 0x27f8: 0x0024, 0x27f9: 0x0024, 0x27fa: 0x0024, 0x27fb: 0x2000, 0x27fc: 0x2000, 0x27fd: 0x0024, 0x27fe: 0x2000, 0x27ff: 0x0024, // Block 0xa0, offset 0x2800 0x2800: 0x0024, // Block 0xa1, offset 0x2840 0x286b: 0x0024, 0x286c: 0x2000, 0x286d: 0x0024, 0x286e: 0x2000, 0x286f: 0x2000, 0x2870: 0x0024, 0x2871: 0x0024, 0x2872: 0x0024, 0x2873: 0x0024, 0x2874: 0x0024, 0x2875: 0x0024, 0x2876: 0x0024, 0x2877: 0x0024, // Block 0xa2, offset 0x2880 0x289d: 0x0024, 0x289e: 0x2000, 0x289f: 0x0024, 0x28a2: 0x0024, 0x28a3: 0x0024, 0x28a4: 0x0024, 0x28a5: 0x0024, 0x28a6: 0x2000, 0x28a7: 0x0024, 0x28a8: 0x0024, 0x28a9: 0x0024, 0x28aa: 0x0024, 0x28ab: 0x0024, // Block 0xa3, offset 0x28c0 0x28ec: 0x2000, 0x28ed: 0x2000, 0x28ee: 0x2000, 0x28ef: 0x0024, 0x28f0: 0x0024, 0x28f1: 0x0024, 0x28f2: 0x0024, 0x28f3: 0x0024, 0x28f4: 0x0024, 0x28f5: 0x0024, 0x28f6: 0x0024, 0x28f7: 0x0024, 0x28f8: 0x2000, 0x28f9: 0x0024, 0x28fa: 0x0024, // Block 0xa4, offset 0x2900 0x2900: 0x0010, 0x2901: 0x0010, 0x2902: 0x0010, 0x2903: 0x0010, 0x2904: 0x0010, 0x2905: 0x0010, 0x2906: 0x0010, 0x2909: 0x0010, 0x290c: 0x0010, 0x290d: 0x0010, 0x290e: 0x0010, 0x290f: 0x0010, 0x2910: 0x0010, 0x2911: 0x0010, 0x2912: 0x0010, 0x2913: 0x0010, 0x2915: 0x0010, 0x2916: 0x0010, 0x2918: 0x0010, 0x2919: 0x0010, 0x291a: 0x0010, 0x291b: 0x0010, 0x291c: 0x0010, 0x291d: 0x0010, 0x291e: 0x0010, 0x291f: 0x0010, 0x2920: 0x0010, 0x2921: 0x0010, 0x2922: 0x0010, 0x2923: 0x0010, 0x2924: 0x0010, 0x2925: 0x0010, 0x2926: 0x0010, 0x2927: 0x0010, 0x2928: 0x0010, 0x2929: 0x0010, 0x292a: 0x0010, 0x292b: 0x0010, 0x292c: 0x0010, 0x292d: 0x0010, 0x292e: 0x0010, 0x292f: 0x0010, 0x2930: 0x0024, 0x2931: 0x2000, 0x2932: 0x2000, 0x2933: 0x2000, 0x2934: 0x2000, 0x2935: 0x2000, 0x2937: 0x2000, 0x2938: 0x2000, 0x293b: 0x0024, 0x293c: 0x0024, 0x293d: 0x0024, 0x293e: 0x0044, 0x293f: 0x0800, // Block 0xa5, offset 0x2940 0x2940: 0x2000, 0x2941: 0x0800, 0x2942: 0x2000, 0x2943: 0x0024, // Block 0xa6, offset 0x2980 0x2991: 0x2000, 0x2992: 0x2000, 0x2993: 0x2000, 0x2994: 0x0024, 0x2995: 0x0024, 0x2996: 0x0024, 0x2997: 0x0024, 0x299a: 0x0024, 0x299b: 0x0024, 0x299c: 0x2000, 0x299d: 0x2000, 0x299e: 0x2000, 0x299f: 0x2000, 0x29a0: 0x0024, 0x29a4: 0x2000, // Block 0xa7, offset 0x29c0 0x29c0: 0x0010, 0x29c1: 0x0024, 0x29c2: 0x0024, 0x29c3: 0x0024, 0x29c4: 0x0024, 0x29c5: 0x0024, 0x29c6: 0x0024, 0x29c7: 0x0024, 0x29c8: 0x0024, 0x29c9: 0x0024, 0x29ca: 0x0024, 0x29cb: 0x0010, 0x29cc: 0x0010, 0x29cd: 0x0010, 0x29ce: 0x0010, 0x29cf: 0x0010, 0x29d0: 0x0010, 0x29d1: 0x0010, 0x29d2: 0x0010, 0x29d3: 0x0010, 0x29d4: 0x0010, 0x29d5: 0x0010, 0x29d6: 0x0010, 0x29d7: 0x0010, 0x29d8: 0x0010, 0x29d9: 0x0010, 0x29da: 0x0010, 0x29db: 0x0010, 0x29dc: 0x0010, 0x29dd: 0x0010, 0x29de: 0x0010, 0x29df: 0x0010, 0x29e0: 0x0010, 0x29e1: 0x0010, 0x29e2: 0x0010, 0x29e3: 0x0010, 0x29e4: 0x0010, 0x29e5: 0x0010, 0x29e6: 0x0010, 0x29e7: 0x0010, 0x29e8: 0x0010, 0x29e9: 0x0010, 0x29ea: 0x0010, 0x29eb: 0x0010, 0x29ec: 0x0010, 0x29ed: 0x0010, 0x29ee: 0x0010, 0x29ef: 0x0010, 0x29f0: 0x0010, 0x29f1: 0x0010, 0x29f2: 0x0010, 0x29f3: 0x0024, 0x29f4: 0x0024, 0x29f5: 0x0024, 0x29f6: 0x0024, 0x29f7: 0x0024, 0x29f8: 0x0024, 0x29f9: 0x2000, 0x29fb: 0x0024, 0x29fc: 0x0024, 0x29fd: 0x0024, 0x29fe: 0x0024, // Block 0xa8, offset 0x2a00 0x2a07: 0x0044, 0x2a10: 0x0010, 0x2a11: 0x0024, 0x2a12: 0x0024, 0x2a13: 0x0024, 0x2a14: 0x0024, 0x2a15: 0x0024, 0x2a16: 0x0024, 0x2a17: 0x2000, 0x2a18: 0x2000, 0x2a19: 0x0024, 0x2a1a: 0x0024, 0x2a1b: 0x0024, 0x2a1c: 0x0010, 0x2a1d: 0x0010, 0x2a1e: 0x0010, 0x2a1f: 0x0010, 0x2a20: 0x0010, 0x2a21: 0x0010, 0x2a22: 0x0010, 0x2a23: 0x0010, 0x2a24: 0x0010, 0x2a25: 0x0010, 0x2a26: 0x0010, 0x2a27: 0x0010, 0x2a28: 0x0010, 0x2a29: 0x0010, 0x2a2a: 0x0010, 0x2a2b: 0x0010, 0x2a2c: 0x0010, 0x2a2d: 0x0010, 0x2a2e: 0x0010, 0x2a2f: 0x0010, 0x2a30: 0x0010, 0x2a31: 0x0010, 0x2a32: 0x0010, 0x2a33: 0x0010, 0x2a34: 0x0010, 0x2a35: 0x0010, 0x2a36: 0x0010, 0x2a37: 0x0010, 0x2a38: 0x0010, 0x2a39: 0x0010, 0x2a3a: 0x0010, 0x2a3b: 0x0010, 0x2a3c: 0x0010, 0x2a3d: 0x0010, 0x2a3e: 0x0010, 0x2a3f: 0x0010, // Block 0xa9, offset 0x2a40 0x2a40: 0x0010, 0x2a41: 0x0010, 0x2a42: 0x0010, 0x2a43: 0x0010, 0x2a44: 0x0800, 0x2a45: 0x0800, 0x2a46: 0x0800, 0x2a47: 0x0800, 0x2a48: 0x0800, 0x2a49: 0x0800, 0x2a4a: 0x0024, 0x2a4b: 0x0024, 0x2a4c: 0x0024, 0x2a4d: 0x0024, 0x2a4e: 0x0024, 0x2a4f: 0x0024, 0x2a50: 0x0024, 0x2a51: 0x0024, 0x2a52: 0x0024, 0x2a53: 0x0024, 0x2a54: 0x0024, 0x2a55: 0x0024, 0x2a56: 0x0024, 0x2a57: 0x2000, 0x2a58: 0x0024, 0x2a59: 0x0044, // Block 0xaa, offset 0x2a80 0x2aa0: 0x0024, 0x2aa1: 0x2000, 0x2aa2: 0x0024, 0x2aa3: 0x0024, 0x2aa4: 0x0024, 0x2aa5: 0x2000, 0x2aa6: 0x0024, 0x2aa7: 0x2000, // Block 0xab, offset 0x2ac0 0x2aef: 0x2000, 0x2af0: 0x0024, 0x2af1: 0x0024, 0x2af2: 0x0024, 0x2af3: 0x0024, 0x2af4: 0x0024, 0x2af5: 0x0024, 0x2af6: 0x0024, 0x2af8: 0x0024, 0x2af9: 0x0024, 0x2afa: 0x0024, 0x2afb: 0x0024, 0x2afc: 0x0024, 0x2afd: 0x0024, 0x2afe: 0x2000, 0x2aff: 0x0024, // Block 0xac, offset 0x2b00 0x2b12: 0x0024, 0x2b13: 0x0024, 0x2b14: 0x0024, 0x2b15: 0x0024, 0x2b16: 0x0024, 0x2b17: 0x0024, 0x2b18: 0x0024, 0x2b19: 0x0024, 0x2b1a: 0x0024, 0x2b1b: 0x0024, 0x2b1c: 0x0024, 0x2b1d: 0x0024, 0x2b1e: 0x0024, 0x2b1f: 0x0024, 0x2b20: 0x0024, 0x2b21: 0x0024, 0x2b22: 0x0024, 0x2b23: 0x0024, 0x2b24: 0x0024, 0x2b25: 0x0024, 0x2b26: 0x0024, 0x2b27: 0x0024, 0x2b29: 0x2000, 0x2b2a: 0x0024, 0x2b2b: 0x0024, 0x2b2c: 0x0024, 0x2b2d: 0x0024, 0x2b2e: 0x0024, 0x2b2f: 0x0024, 0x2b30: 0x0024, 0x2b31: 0x2000, 0x2b32: 0x0024, 0x2b33: 0x0024, 0x2b34: 0x2000, 0x2b35: 0x0024, 0x2b36: 0x0024, // Block 0xad, offset 0x2b40 0x2b71: 0x0024, 0x2b72: 0x0024, 0x2b73: 0x0024, 0x2b74: 0x0024, 0x2b75: 0x0024, 0x2b76: 0x0024, 0x2b7a: 0x0024, 0x2b7c: 0x0024, 0x2b7d: 0x0024, 0x2b7f: 0x0024, // Block 0xae, offset 0x2b80 0x2b80: 0x0024, 0x2b81: 0x0024, 0x2b82: 0x0024, 0x2b83: 0x0024, 0x2b84: 0x0024, 0x2b85: 0x0024, 0x2b86: 0x0800, 0x2b87: 0x0024, // Block 0xaf, offset 0x2bc0 0x2bca: 0x2000, 0x2bcb: 0x2000, 0x2bcc: 0x2000, 0x2bcd: 0x2000, 0x2bce: 0x2000, 0x2bd0: 0x0024, 0x2bd1: 0x0024, 0x2bd3: 0x2000, 0x2bd4: 0x2000, 0x2bd5: 0x0024, 0x2bd6: 0x2000, 0x2bd7: 0x0024, // Block 0xb0, offset 0x2c00 0x2c33: 0x0024, 0x2c34: 0x0024, 0x2c35: 0x2000, 0x2c36: 0x2000, // Block 0xb1, offset 0x2c40 0x2c40: 0x0024, 0x2c41: 0x0024, 0x2c42: 0x0800, 0x2c43: 0x2000, 0x2c44: 0x0010, 0x2c45: 0x0010, 0x2c46: 0x0010, 0x2c47: 0x0010, 0x2c48: 0x0010, 0x2c49: 0x0010, 0x2c4a: 0x0010, 0x2c4b: 0x0010, 0x2c4c: 0x0010, 0x2c4d: 0x0010, 0x2c4e: 0x0010, 0x2c4f: 0x0010, 0x2c50: 0x0010, 0x2c52: 0x0010, 0x2c53: 0x0010, 0x2c54: 0x0010, 0x2c55: 0x0010, 0x2c56: 0x0010, 0x2c57: 0x0010, 0x2c58: 0x0010, 0x2c59: 0x0010, 0x2c5a: 0x0010, 0x2c5b: 0x0010, 0x2c5c: 0x0010, 0x2c5d: 0x0010, 0x2c5e: 0x0010, 0x2c5f: 0x0010, 0x2c60: 0x0010, 0x2c61: 0x0010, 0x2c62: 0x0010, 0x2c63: 0x0010, 0x2c64: 0x0010, 0x2c65: 0x0010, 0x2c66: 0x0010, 0x2c67: 0x0010, 0x2c68: 0x0010, 0x2c69: 0x0010, 0x2c6a: 0x0010, 0x2c6b: 0x0010, 0x2c6c: 0x0010, 0x2c6d: 0x0010, 0x2c6e: 0x0010, 0x2c6f: 0x0010, 0x2c70: 0x0010, 0x2c71: 0x0010, 0x2c72: 0x0010, 0x2c73: 0x0010, 0x2c74: 0x2000, 0x2c75: 0x2000, 0x2c76: 0x0024, 0x2c77: 0x0024, 0x2c78: 0x0024, 0x2c79: 0x0024, 0x2c7a: 0x0024, 0x2c7e: 0x2000, 0x2c7f: 0x2000, // Block 0xb2, offset 0x2c80 0x2c80: 0x0024, 0x2c81: 0x0024, 0x2c82: 0x0044, 0x2c9a: 0x0024, // Block 0xb3, offset 0x2cc0 0x2cf0: 0x0002, 0x2cf1: 0x0002, 0x2cf2: 0x0002, 0x2cf3: 0x0002, 0x2cf4: 0x0002, 0x2cf5: 0x0002, 0x2cf6: 0x0002, 0x2cf7: 0x0002, 0x2cf8: 0x0002, 0x2cf9: 0x0002, 0x2cfa: 0x0002, 0x2cfb: 0x0002, 0x2cfc: 0x0002, 0x2cfd: 0x0002, 0x2cfe: 0x0002, 0x2cff: 0x0002, // Block 0xb4, offset 0x2d00 0x2d00: 0x0024, 0x2d07: 0x0024, 0x2d08: 0x0024, 0x2d09: 0x0024, 0x2d0a: 0x0024, 0x2d0b: 0x0024, 0x2d0c: 0x0024, 0x2d0d: 0x0024, 0x2d0e: 0x0024, 0x2d0f: 0x0024, 0x2d10: 0x0024, 0x2d11: 0x0024, 0x2d12: 0x0024, 0x2d13: 0x0024, 0x2d14: 0x0024, 0x2d15: 0x0024, // Block 0xb5, offset 0x2d40 0x2d5e: 0x0024, 0x2d5f: 0x0024, 0x2d60: 0x0024, 0x2d61: 0x0024, 0x2d62: 0x0024, 0x2d63: 0x0024, 0x2d64: 0x0024, 0x2d65: 0x0024, 0x2d66: 0x0024, 0x2d67: 0x0024, 0x2d68: 0x0024, 0x2d69: 0x0024, 0x2d6a: 0x2000, 0x2d6b: 0x2000, 0x2d6c: 0x2000, 0x2d6d: 0x0024, 0x2d6e: 0x0024, 0x2d6f: 0x0024, // Block 0xb6, offset 0x2d80 0x2db0: 0x0024, 0x2db1: 0x0024, 0x2db2: 0x0024, 0x2db3: 0x0024, 0x2db4: 0x0024, // Block 0xb7, offset 0x2dc0 0x2df0: 0x0024, 0x2df1: 0x0024, 0x2df2: 0x0024, 0x2df3: 0x0024, 0x2df4: 0x0024, 0x2df5: 0x0024, 0x2df6: 0x0024, // Block 0xb8, offset 0x2e00 0x2e23: 0x8000, 0x2e27: 0x8000, 0x2e28: 0x8000, 0x2e29: 0x8000, 0x2e2a: 0x8000, // Block 0xb9, offset 0x2e40 0x2e4f: 0x0024, 0x2e51: 0x2000, 0x2e52: 0x2000, 0x2e53: 0x2000, 0x2e54: 0x2000, 0x2e55: 0x2000, 0x2e56: 0x2000, 0x2e57: 0x2000, 0x2e58: 0x2000, 0x2e59: 0x2000, 0x2e5a: 0x2000, 0x2e5b: 0x2000, 0x2e5c: 0x2000, 0x2e5d: 0x2000, 0x2e5e: 0x2000, 0x2e5f: 0x2000, 0x2e60: 0x2000, 0x2e61: 0x2000, 0x2e62: 0x2000, 0x2e63: 0x2000, 0x2e64: 0x2000, 0x2e65: 0x2000, 0x2e66: 0x2000, 0x2e67: 0x2000, 0x2e68: 0x2000, 0x2e69: 0x2000, 0x2e6a: 0x2000, 0x2e6b: 0x2000, 0x2e6c: 0x2000, 0x2e6d: 0x2000, 0x2e6e: 0x2000, 0x2e6f: 0x2000, 0x2e70: 0x2000, 0x2e71: 0x2000, 0x2e72: 0x2000, 0x2e73: 0x2000, 0x2e74: 0x2000, 0x2e75: 0x2000, 0x2e76: 0x2000, 0x2e77: 0x2000, 0x2e78: 0x2000, 0x2e79: 0x2000, 0x2e7a: 0x2000, 0x2e7b: 0x2000, 0x2e7c: 0x2000, 0x2e7d: 0x2000, 0x2e7e: 0x2000, 0x2e7f: 0x2000, // Block 0xba, offset 0x2e80 0x2e80: 0x2000, 0x2e81: 0x2000, 0x2e82: 0x2000, 0x2e83: 0x2000, 0x2e84: 0x2000, 0x2e85: 0x2000, 0x2e86: 0x2000, 0x2e87: 0x2000, 0x2e8f: 0x0024, 0x2e90: 0x0024, 0x2e91: 0x0024, 0x2e92: 0x0024, // Block 0xbb, offset 0x2ec0 0x2ee4: 0x0024, 0x2ef0: 0x0024, 0x2ef1: 0x0024, // Block 0xbc, offset 0x2f00 0x2f1d: 0x0024, 0x2f1e: 0x0024, 0x2f20: 0x0002, 0x2f21: 0x0002, 0x2f22: 0x0002, 0x2f23: 0x0002, // Block 0xbd, offset 0x2f40 0x2f40: 0x0024, 0x2f41: 0x0024, 0x2f42: 0x0024, 0x2f43: 0x0024, 0x2f44: 0x0024, 0x2f45: 0x0024, 0x2f46: 0x0024, 0x2f47: 0x0024, 0x2f48: 0x0024, 0x2f49: 0x0024, 0x2f4a: 0x0024, 0x2f4b: 0x0024, 0x2f4c: 0x0024, 0x2f4d: 0x0024, 0x2f4e: 0x0024, 0x2f4f: 0x0024, 0x2f50: 0x0024, 0x2f51: 0x0024, 0x2f52: 0x0024, 0x2f53: 0x0024, 0x2f54: 0x0024, 0x2f55: 0x0024, 0x2f56: 0x0024, 0x2f57: 0x0024, 0x2f58: 0x0024, 0x2f59: 0x0024, 0x2f5a: 0x0024, 0x2f5b: 0x0024, 0x2f5c: 0x0024, 0x2f5d: 0x0024, 0x2f5e: 0x0024, 0x2f5f: 0x0024, 0x2f60: 0x0024, 0x2f61: 0x0024, 0x2f62: 0x0024, 0x2f63: 0x0024, 0x2f64: 0x0024, 0x2f65: 0x0024, 0x2f66: 0x0024, 0x2f67: 0x0024, 0x2f68: 0x0024, 0x2f69: 0x0024, 0x2f6a: 0x0024, 0x2f6b: 0x0024, 0x2f6c: 0x0024, 0x2f6d: 0x0024, 0x2f70: 0x0024, 0x2f71: 0x0024, 0x2f72: 0x0024, 0x2f73: 0x0024, 0x2f74: 0x0024, 0x2f75: 0x0024, 0x2f76: 0x0024, 0x2f77: 0x0024, 0x2f78: 0x0024, 0x2f79: 0x0024, 0x2f7a: 0x0024, 0x2f7b: 0x0024, 0x2f7c: 0x0024, 0x2f7d: 0x0024, 0x2f7e: 0x0024, 0x2f7f: 0x0024, // Block 0xbe, offset 0x2f80 0x2f80: 0x0024, 0x2f81: 0x0024, 0x2f82: 0x0024, 0x2f83: 0x0024, 0x2f84: 0x0024, 0x2f85: 0x0024, 0x2f86: 0x0024, // Block 0xbf, offset 0x2fc0 0x2fe5: 0x0024, 0x2fe6: 0x0024, 0x2fe7: 0x0024, 0x2fe8: 0x0024, 0x2fe9: 0x0024, 0x2fed: 0x0024, 0x2fee: 0x0024, 0x2fef: 0x0024, 0x2ff0: 0x0024, 0x2ff1: 0x0024, 0x2ff2: 0x0024, 0x2ff3: 0x0002, 0x2ff4: 0x0002, 0x2ff5: 0x0002, 0x2ff6: 0x0002, 0x2ff7: 0x0002, 0x2ff8: 0x0002, 0x2ff9: 0x0002, 0x2ffa: 0x0002, 0x2ffb: 0x0024, 0x2ffc: 0x0024, 0x2ffd: 0x0024, 0x2ffe: 0x0024, 0x2fff: 0x0024, // Block 0xc0, offset 0x3000 0x3000: 0x0024, 0x3001: 0x0024, 0x3002: 0x0024, 0x3005: 0x0024, 0x3006: 0x0024, 0x3007: 0x0024, 0x3008: 0x0024, 0x3009: 0x0024, 0x300a: 0x0024, 0x300b: 0x0024, 0x302a: 0x0024, 0x302b: 0x0024, 0x302c: 0x0024, 0x302d: 0x0024, // Block 0xc1, offset 0x3040 0x3042: 0x0024, 0x3043: 0x0024, 0x3044: 0x0024, // Block 0xc2, offset 0x3080 0x3080: 0x0024, 0x3081: 0x0024, 0x3082: 0x0024, 0x3083: 0x0024, 0x3084: 0x0024, 0x3085: 0x0024, 0x3086: 0x0024, 0x3087: 0x0024, 0x3088: 0x0024, 0x3089: 0x0024, 0x308a: 0x0024, 0x308b: 0x0024, 0x308c: 0x0024, 0x308d: 0x0024, 0x308e: 0x0024, 0x308f: 0x0024, 0x3090: 0x0024, 0x3091: 0x0024, 0x3092: 0x0024, 0x3093: 0x0024, 0x3094: 0x0024, 0x3095: 0x0024, 0x3096: 0x0024, 0x3097: 0x0024, 0x3098: 0x0024, 0x3099: 0x0024, 0x309a: 0x0024, 0x309b: 0x0024, 0x309c: 0x0024, 0x309d: 0x0024, 0x309e: 0x0024, 0x309f: 0x0024, 0x30a0: 0x0024, 0x30a1: 0x0024, 0x30a2: 0x0024, 0x30a3: 0x0024, 0x30a4: 0x0024, 0x30a5: 0x0024, 0x30a6: 0x0024, 0x30a7: 0x0024, 0x30a8: 0x0024, 0x30a9: 0x0024, 0x30aa: 0x0024, 0x30ab: 0x0024, 0x30ac: 0x0024, 0x30ad: 0x0024, 0x30ae: 0x0024, 0x30af: 0x0024, 0x30b0: 0x0024, 0x30b1: 0x0024, 0x30b2: 0x0024, 0x30b3: 0x0024, 0x30b4: 0x0024, 0x30b5: 0x0024, 0x30b6: 0x0024, 0x30bb: 0x0024, 0x30bc: 0x0024, 0x30bd: 0x0024, 0x30be: 0x0024, 0x30bf: 0x0024, // Block 0xc3, offset 0x30c0 0x30c0: 0x0024, 0x30c1: 0x0024, 0x30c2: 0x0024, 0x30c3: 0x0024, 0x30c4: 0x0024, 0x30c5: 0x0024, 0x30c6: 0x0024, 0x30c7: 0x0024, 0x30c8: 0x0024, 0x30c9: 0x0024, 0x30ca: 0x0024, 0x30cb: 0x0024, 0x30cc: 0x0024, 0x30cd: 0x0024, 0x30ce: 0x0024, 0x30cf: 0x0024, 0x30d0: 0x0024, 0x30d1: 0x0024, 0x30d2: 0x0024, 0x30d3: 0x0024, 0x30d4: 0x0024, 0x30d5: 0x0024, 0x30d6: 0x0024, 0x30d7: 0x0024, 0x30d8: 0x0024, 0x30d9: 0x0024, 0x30da: 0x0024, 0x30db: 0x0024, 0x30dc: 0x0024, 0x30dd: 0x0024, 0x30de: 0x0024, 0x30df: 0x0024, 0x30e0: 0x0024, 0x30e1: 0x0024, 0x30e2: 0x0024, 0x30e3: 0x0024, 0x30e4: 0x0024, 0x30e5: 0x0024, 0x30e6: 0x0024, 0x30e7: 0x0024, 0x30e8: 0x0024, 0x30e9: 0x0024, 0x30ea: 0x0024, 0x30eb: 0x0024, 0x30ec: 0x0024, 0x30f5: 0x0024, // Block 0xc4, offset 0x3100 0x3104: 0x0024, 0x311b: 0x0024, 0x311c: 0x0024, 0x311d: 0x0024, 0x311e: 0x0024, 0x311f: 0x0024, 0x3121: 0x0024, 0x3122: 0x0024, 0x3123: 0x0024, 0x3124: 0x0024, 0x3125: 0x0024, 0x3126: 0x0024, 0x3127: 0x0024, 0x3128: 0x0024, 0x3129: 0x0024, 0x312a: 0x0024, 0x312b: 0x0024, 0x312c: 0x0024, 0x312d: 0x0024, 0x312e: 0x0024, 0x312f: 0x0024, // Block 0xc5, offset 0x3140 0x3140: 0x0024, 0x3141: 0x0024, 0x3142: 0x0024, 0x3143: 0x0024, 0x3144: 0x0024, 0x3145: 0x0024, 0x3146: 0x0024, 0x3148: 0x0024, 0x3149: 0x0024, 0x314a: 0x0024, 0x314b: 0x0024, 0x314c: 0x0024, 0x314d: 0x0024, 0x314e: 0x0024, 0x314f: 0x0024, 0x3150: 0x0024, 0x3151: 0x0024, 0x3152: 0x0024, 0x3153: 0x0024, 0x3154: 0x0024, 0x3155: 0x0024, 0x3156: 0x0024, 0x3157: 0x0024, 0x3158: 0x0024, 0x315b: 0x0024, 0x315c: 0x0024, 0x315d: 0x0024, 0x315e: 0x0024, 0x315f: 0x0024, 0x3160: 0x0024, 0x3161: 0x0024, 0x3163: 0x0024, 0x3164: 0x0024, 0x3166: 0x0024, 0x3167: 0x0024, 0x3168: 0x0024, 0x3169: 0x0024, 0x316a: 0x0024, // Block 0xc6, offset 0x3180 0x318f: 0x0024, // Block 0xc7, offset 0x31c0 0x31ee: 0x0024, // Block 0xc8, offset 0x3200 0x322c: 0x0024, 0x322d: 0x0024, 0x322e: 0x0024, 0x322f: 0x0024, // Block 0xc9, offset 0x3240 0x326e: 0x0024, 0x326f: 0x0024, // Block 0xca, offset 0x3280 0x32a3: 0x0024, 0x32a6: 0x0024, 0x32ae: 0x0024, 0x32af: 0x0024, 0x32b5: 0x0024, // Block 0xcb, offset 0x32c0 0x32d0: 0x0024, 0x32d1: 0x0024, 0x32d2: 0x0024, 0x32d3: 0x0024, 0x32d4: 0x0024, 0x32d5: 0x0024, 0x32d6: 0x0024, // Block 0xcc, offset 0x3300 0x3304: 0x0024, 0x3305: 0x0024, 0x3306: 0x0024, 0x3307: 0x0024, 0x3308: 0x0024, 0x3309: 0x0024, 0x330a: 0x0024, // Block 0xcd, offset 0x3340 0x3344: 0x0008, 0x336c: 0x0008, 0x336d: 0x0008, 0x336e: 0x0008, 0x336f: 0x0008, // Block 0xce, offset 0x3380 0x3394: 0x0008, 0x3395: 0x0008, 0x3396: 0x0008, 0x3397: 0x0008, 0x3398: 0x0008, 0x3399: 0x0008, 0x339a: 0x0008, 0x339b: 0x0008, 0x339c: 0x0008, 0x339d: 0x0008, 0x339e: 0x0008, 0x339f: 0x0008, 0x33af: 0x0008, 0x33b0: 0x0008, // Block 0xcf, offset 0x33c0 0x33c0: 0x0008, 0x33cf: 0x0008, 0x33d0: 0x0008, 0x33f6: 0x0008, 0x33f7: 0x0008, 0x33f8: 0x0008, 0x33f9: 0x0008, 0x33fa: 0x0008, 0x33fb: 0x0008, 0x33fc: 0x0008, 0x33fd: 0x0008, 0x33fe: 0x0008, 0x33ff: 0x0008, // Block 0xd0, offset 0x3400 0x3430: 0x0008, 0x3431: 0x0008, 0x343e: 0x0008, 0x343f: 0x0008, // Block 0xd1, offset 0x3440 0x344e: 0x0008, 0x3451: 0x0008, 0x3452: 0x0008, 0x3453: 0x0008, 0x3454: 0x0008, 0x3455: 0x0008, 0x3456: 0x0008, 0x3457: 0x0008, 0x3458: 0x0008, 0x3459: 0x0008, 0x345a: 0x0008, 0x346e: 0x0008, 0x346f: 0x0008, 0x3470: 0x0008, 0x3471: 0x0008, 0x3472: 0x0008, 0x3473: 0x0008, 0x3474: 0x0008, 0x3475: 0x0008, 0x3476: 0x0008, 0x3477: 0x0008, 0x3478: 0x0008, 0x3479: 0x0008, 0x347a: 0x0008, 0x347b: 0x0008, 0x347c: 0x0008, 0x347d: 0x0008, 0x347e: 0x0008, 0x347f: 0x0008, // Block 0xd2, offset 0x3480 0x3480: 0x0008, 0x3481: 0x0008, 0x3482: 0x0008, 0x3483: 0x0008, 0x3484: 0x0008, 0x3485: 0x0008, 0x3486: 0x0008, 0x3487: 0x0008, 0x3488: 0x0008, 0x3489: 0x0008, 0x348a: 0x0008, 0x348b: 0x0008, 0x348c: 0x0008, 0x348d: 0x0008, 0x348e: 0x0008, 0x348f: 0x0008, 0x3490: 0x0008, 0x3491: 0x0008, 0x3492: 0x0008, 0x3493: 0x0008, 0x3494: 0x0008, 0x3495: 0x0008, 0x3496: 0x0008, 0x3497: 0x0008, 0x3498: 0x0008, 0x3499: 0x0008, 0x349a: 0x0008, 0x349b: 0x0008, 0x349c: 0x0008, 0x349d: 0x0008, 0x349e: 0x0008, 0x349f: 0x0008, 0x34a0: 0x0008, 0x34a1: 0x0008, 0x34a2: 0x0008, 0x34a3: 0x0008, 0x34a4: 0x0008, 0x34a5: 0x0008, 0x34a6: 0x1000, 0x34a7: 0x1000, 0x34a8: 0x1000, 0x34a9: 0x1000, 0x34aa: 0x1000, 0x34ab: 0x1000, 0x34ac: 0x1000, 0x34ad: 0x1000, 0x34ae: 0x1000, 0x34af: 0x1000, 0x34b0: 0x1000, 0x34b1: 0x1000, 0x34b2: 0x1000, 0x34b3: 0x1000, 0x34b4: 0x1000, 0x34b5: 0x1000, 0x34b6: 0x1000, 0x34b7: 0x1000, 0x34b8: 0x1000, 0x34b9: 0x1000, 0x34ba: 0x1000, 0x34bb: 0x1000, 0x34bc: 0x1000, 0x34bd: 0x1000, 0x34be: 0x1000, 0x34bf: 0x1000, // Block 0xd3, offset 0x34c0 0x34c1: 0x0008, 0x34c2: 0x0008, 0x34c3: 0x0008, 0x34c4: 0x0008, 0x34c5: 0x0008, 0x34c6: 0x0008, 0x34c7: 0x0008, 0x34c8: 0x0008, 0x34c9: 0x0008, 0x34ca: 0x0008, 0x34cb: 0x0008, 0x34cc: 0x0008, 0x34cd: 0x0008, 0x34ce: 0x0008, 0x34cf: 0x0008, 0x34da: 0x0008, 0x34ef: 0x0008, 0x34f2: 0x0008, 0x34f3: 0x0008, 0x34f4: 0x0008, 0x34f5: 0x0008, 0x34f6: 0x0008, 0x34f7: 0x0008, 0x34f8: 0x0008, 0x34f9: 0x0008, 0x34fa: 0x0008, 0x34fc: 0x0008, 0x34fd: 0x0008, 0x34fe: 0x0008, 0x34ff: 0x0008, // Block 0xd4, offset 0x3500 0x3509: 0x0008, 0x350a: 0x0008, 0x350b: 0x0008, 0x350c: 0x0008, 0x350d: 0x0008, 0x350e: 0x0008, 0x350f: 0x0008, 0x3510: 0x0008, 0x3511: 0x0008, 0x3512: 0x0008, 0x3513: 0x0008, 0x3514: 0x0008, 0x3515: 0x0008, 0x3516: 0x0008, 0x3517: 0x0008, 0x3518: 0x0008, 0x3519: 0x0008, 0x351a: 0x0008, 0x351b: 0x0008, 0x351c: 0x0008, 0x351d: 0x0008, 0x351e: 0x0008, 0x351f: 0x0008, 0x3526: 0x0008, 0x3527: 0x0008, 0x3528: 0x0008, 0x3529: 0x0008, 0x352a: 0x0008, 0x352b: 0x0008, 0x352c: 0x0008, 0x352d: 0x0008, 0x352e: 0x0008, 0x352f: 0x0008, 0x3530: 0x0008, 0x3531: 0x0008, 0x3532: 0x0008, 0x3533: 0x0008, 0x3534: 0x0008, 0x3535: 0x0008, 0x3536: 0x0008, 0x3537: 0x0008, 0x3538: 0x0008, 0x3539: 0x0008, 0x353a: 0x0008, 0x353b: 0x0008, 0x353c: 0x0008, 0x353d: 0x0008, 0x353e: 0x0008, 0x353f: 0x0008, // Block 0xd5, offset 0x3540 0x3540: 0x0008, 0x3541: 0x0008, 0x3542: 0x0008, 0x3543: 0x0008, 0x3544: 0x0008, 0x3545: 0x0008, 0x3546: 0x0008, 0x3547: 0x0008, 0x3548: 0x0008, 0x3549: 0x0008, 0x354a: 0x0008, 0x354b: 0x0008, 0x354c: 0x0008, 0x354d: 0x0008, 0x354e: 0x0008, 0x354f: 0x0008, 0x3550: 0x0008, 0x3551: 0x0008, 0x3552: 0x0008, 0x3553: 0x0008, 0x3554: 0x0008, 0x3555: 0x0008, 0x3556: 0x0008, 0x3557: 0x0008, 0x3558: 0x0008, 0x3559: 0x0008, 0x355a: 0x0008, 0x355b: 0x0008, 0x355c: 0x0008, 0x355d: 0x0008, 0x355e: 0x0008, 0x355f: 0x0008, 0x3560: 0x0008, 0x3561: 0x0008, 0x3562: 0x0008, 0x3563: 0x0008, 0x3564: 0x0008, 0x3565: 0x0008, 0x3566: 0x0008, 0x3567: 0x0008, 0x3568: 0x0008, 0x3569: 0x0008, 0x356a: 0x0008, 0x356b: 0x0008, 0x356c: 0x0008, 0x356d: 0x0008, 0x356e: 0x0008, 0x356f: 0x0008, 0x3570: 0x0008, 0x3571: 0x0008, 0x3572: 0x0008, 0x3573: 0x0008, 0x3574: 0x0008, 0x3575: 0x0008, 0x3576: 0x0008, 0x3577: 0x0008, 0x3578: 0x0008, 0x3579: 0x0008, 0x357a: 0x0008, 0x357b: 0x0008, 0x357c: 0x0008, 0x357d: 0x0008, 0x357e: 0x0008, 0x357f: 0x0008, // Block 0xd6, offset 0x3580 0x3580: 0x0008, 0x3581: 0x0008, 0x3582: 0x0008, 0x3583: 0x0008, 0x3584: 0x0008, 0x3585: 0x0008, 0x3586: 0x0008, 0x3587: 0x0008, 0x3588: 0x0008, 0x3589: 0x0008, 0x358a: 0x0008, 0x358b: 0x0008, 0x358c: 0x0008, 0x358d: 0x0008, 0x358e: 0x0008, 0x358f: 0x0008, 0x3590: 0x0008, 0x3591: 0x0008, 0x3592: 0x0008, 0x3593: 0x0008, 0x3594: 0x0008, 0x3595: 0x0008, 0x3596: 0x0008, 0x3597: 0x0008, 0x3598: 0x0008, 0x3599: 0x0008, 0x359a: 0x0008, 0x359b: 0x0008, 0x359c: 0x0008, 0x359d: 0x0008, 0x359e: 0x0008, 0x359f: 0x0008, 0x35a0: 0x0008, 0x35a1: 0x0008, 0x35a4: 0x0008, 0x35a5: 0x0008, 0x35a6: 0x0008, 0x35a7: 0x0008, 0x35a8: 0x0008, 0x35a9: 0x0008, 0x35aa: 0x0008, 0x35ab: 0x0008, 0x35ac: 0x0008, 0x35ad: 0x0008, 0x35ae: 0x0008, 0x35af: 0x0008, 0x35b0: 0x0008, 0x35b1: 0x0008, 0x35b2: 0x0008, 0x35b3: 0x0008, 0x35b4: 0x0008, 0x35b5: 0x0008, 0x35b6: 0x0008, 0x35b7: 0x0008, 0x35b8: 0x0008, 0x35b9: 0x0008, 0x35ba: 0x0008, 0x35bb: 0x0008, 0x35bc: 0x0008, 0x35bd: 0x0008, 0x35be: 0x0008, 0x35bf: 0x0008, // Block 0xd7, offset 0x35c0 0x35c0: 0x0008, 0x35c1: 0x0008, 0x35c2: 0x0008, 0x35c3: 0x0008, 0x35c4: 0x0008, 0x35c5: 0x0008, 0x35c6: 0x0008, 0x35c7: 0x0008, 0x35c8: 0x0008, 0x35c9: 0x0008, 0x35ca: 0x0008, 0x35cb: 0x0008, 0x35cc: 0x0008, 0x35cd: 0x0008, 0x35ce: 0x0008, 0x35cf: 0x0008, 0x35d0: 0x0008, 0x35d1: 0x0008, 0x35d2: 0x0008, 0x35d3: 0x0008, 0x35d6: 0x0008, 0x35d7: 0x0008, 0x35d9: 0x0008, 0x35da: 0x0008, 0x35db: 0x0008, 0x35de: 0x0008, 0x35df: 0x0008, 0x35e0: 0x0008, 0x35e1: 0x0008, 0x35e2: 0x0008, 0x35e3: 0x0008, 0x35e4: 0x0008, 0x35e5: 0x0008, 0x35e6: 0x0008, 0x35e7: 0x0008, 0x35e8: 0x0008, 0x35e9: 0x0008, 0x35ea: 0x0008, 0x35eb: 0x0008, 0x35ec: 0x0008, 0x35ed: 0x0008, 0x35ee: 0x0008, 0x35ef: 0x0008, 0x35f0: 0x0008, 0x35f1: 0x0008, 0x35f2: 0x0008, 0x35f3: 0x0008, 0x35f4: 0x0008, 0x35f5: 0x0008, 0x35f6: 0x0008, 0x35f7: 0x0008, 0x35f8: 0x0008, 0x35f9: 0x0008, 0x35fa: 0x0008, 0x35fb: 0x0008, 0x35fc: 0x0008, 0x35fd: 0x0008, 0x35fe: 0x0008, 0x35ff: 0x0008, // Block 0xd8, offset 0x3600 0x3600: 0x0008, 0x3601: 0x0008, 0x3602: 0x0008, 0x3603: 0x0008, 0x3604: 0x0008, 0x3605: 0x0008, 0x3606: 0x0008, 0x3607: 0x0008, 0x3608: 0x0008, 0x3609: 0x0008, 0x360a: 0x0008, 0x360b: 0x0008, 0x360c: 0x0008, 0x360d: 0x0008, 0x360e: 0x0008, 0x360f: 0x0008, 0x3610: 0x0008, 0x3611: 0x0008, 0x3612: 0x0008, 0x3613: 0x0008, 0x3614: 0x0008, 0x3615: 0x0008, 0x3616: 0x0008, 0x3617: 0x0008, 0x3618: 0x0008, 0x3619: 0x0008, 0x361a: 0x0008, 0x361b: 0x0008, 0x361c: 0x0008, 0x361d: 0x0008, 0x361e: 0x0008, 0x361f: 0x0008, 0x3620: 0x0008, 0x3621: 0x0008, 0x3622: 0x0008, 0x3623: 0x0008, 0x3624: 0x0008, 0x3625: 0x0008, 0x3626: 0x0008, 0x3627: 0x0008, 0x3628: 0x0008, 0x3629: 0x0008, 0x362a: 0x0008, 0x362b: 0x0008, 0x362c: 0x0008, 0x362d: 0x0008, 0x362e: 0x0008, 0x362f: 0x0008, 0x3630: 0x0008, 0x3633: 0x0008, 0x3634: 0x0008, 0x3635: 0x0008, 0x3637: 0x0008, 0x3638: 0x0008, 0x3639: 0x0008, 0x363a: 0x0008, 0x363b: 0x0024, 0x363c: 0x0024, 0x363d: 0x0024, 0x363e: 0x0024, 0x363f: 0x0024, // Block 0xd9, offset 0x3640 0x3640: 0x0008, 0x3641: 0x0008, 0x3642: 0x0008, 0x3643: 0x0008, 0x3644: 0x0008, 0x3645: 0x0008, 0x3646: 0x0008, 0x3647: 0x0008, 0x3648: 0x0008, 0x3649: 0x0008, 0x364a: 0x0008, 0x364b: 0x0008, 0x364c: 0x0008, 0x364d: 0x0008, 0x364e: 0x0008, 0x364f: 0x0008, 0x3650: 0x0008, 0x3651: 0x0008, 0x3652: 0x0008, 0x3653: 0x0008, 0x3654: 0x0008, 0x3655: 0x0008, 0x3656: 0x0008, 0x3657: 0x0008, 0x3658: 0x0008, 0x3659: 0x0008, 0x365a: 0x0008, 0x365b: 0x0008, 0x365c: 0x0008, 0x365d: 0x0008, 0x365e: 0x0008, 0x365f: 0x0008, 0x3660: 0x0008, 0x3661: 0x0008, 0x3662: 0x0008, 0x3663: 0x0008, 0x3664: 0x0008, 0x3665: 0x0008, 0x3666: 0x0008, 0x3667: 0x0008, 0x3668: 0x0008, 0x3669: 0x0008, 0x366a: 0x0008, 0x366b: 0x0008, 0x366c: 0x0008, 0x366d: 0x0008, 0x366e: 0x0008, 0x366f: 0x0008, 0x3670: 0x0008, 0x3671: 0x0008, 0x3672: 0x0008, 0x3673: 0x0008, 0x3674: 0x0008, 0x3675: 0x0008, 0x3676: 0x0008, 0x3677: 0x0008, 0x3678: 0x0008, 0x3679: 0x0008, 0x367a: 0x0008, 0x367b: 0x0008, 0x367c: 0x0008, 0x367d: 0x0008, 0x367f: 0x0008, // Block 0xda, offset 0x3680 0x3680: 0x0008, 0x3681: 0x0008, 0x3682: 0x0008, 0x3683: 0x0008, 0x3684: 0x0008, 0x3685: 0x0008, 0x3686: 0x0008, 0x3687: 0x0008, 0x3688: 0x0008, 0x3689: 0x0008, 0x368a: 0x0008, 0x368b: 0x0008, 0x368c: 0x0008, 0x368d: 0x0008, 0x368e: 0x0008, 0x368f: 0x0008, 0x3690: 0x0008, 0x3691: 0x0008, 0x3692: 0x0008, 0x3693: 0x0008, 0x3694: 0x0008, 0x3695: 0x0008, 0x3696: 0x0008, 0x3697: 0x0008, 0x3698: 0x0008, 0x3699: 0x0008, 0x369a: 0x0008, 0x369b: 0x0008, 0x369c: 0x0008, 0x369d: 0x0008, 0x369e: 0x0008, 0x369f: 0x0008, 0x36a0: 0x0008, 0x36a1: 0x0008, 0x36a2: 0x0008, 0x36a3: 0x0008, 0x36a4: 0x0008, 0x36a5: 0x0008, 0x36a6: 0x0008, 0x36a7: 0x0008, 0x36a8: 0x0008, 0x36a9: 0x0008, 0x36aa: 0x0008, 0x36ab: 0x0008, 0x36ac: 0x0008, 0x36ad: 0x0008, 0x36ae: 0x0008, 0x36af: 0x0008, 0x36b0: 0x0008, 0x36b1: 0x0008, 0x36b2: 0x0008, 0x36b3: 0x0008, 0x36b4: 0x0008, 0x36b5: 0x0008, 0x36b6: 0x0008, 0x36b7: 0x0008, 0x36b8: 0x0008, 0x36b9: 0x0008, 0x36ba: 0x0008, 0x36bb: 0x0008, 0x36bc: 0x0008, 0x36bd: 0x0008, // Block 0xdb, offset 0x36c0 0x36c9: 0x0008, 0x36ca: 0x0008, 0x36cb: 0x0008, 0x36cc: 0x0008, 0x36cd: 0x0008, 0x36ce: 0x0008, 0x36d0: 0x0008, 0x36d1: 0x0008, 0x36d2: 0x0008, 0x36d3: 0x0008, 0x36d4: 0x0008, 0x36d5: 0x0008, 0x36d6: 0x0008, 0x36d7: 0x0008, 0x36d8: 0x0008, 0x36d9: 0x0008, 0x36da: 0x0008, 0x36db: 0x0008, 0x36dc: 0x0008, 0x36dd: 0x0008, 0x36de: 0x0008, 0x36df: 0x0008, 0x36e0: 0x0008, 0x36e1: 0x0008, 0x36e2: 0x0008, 0x36e3: 0x0008, 0x36e4: 0x0008, 0x36e5: 0x0008, 0x36e6: 0x0008, 0x36e7: 0x0008, 0x36ef: 0x0008, 0x36f0: 0x0008, 0x36f3: 0x0008, 0x36f4: 0x0008, 0x36f5: 0x0008, 0x36f6: 0x0008, 0x36f7: 0x0008, 0x36f8: 0x0008, 0x36f9: 0x0008, 0x36fa: 0x0008, // Block 0xdc, offset 0x3700 0x3707: 0x0008, 0x370a: 0x0008, 0x370b: 0x0008, 0x370c: 0x0008, 0x370d: 0x0008, 0x3710: 0x0008, 0x3715: 0x0008, 0x3716: 0x0008, 0x3724: 0x0008, 0x3725: 0x0008, 0x3728: 0x0008, 0x3731: 0x0008, 0x3732: 0x0008, 0x373c: 0x0008, // Block 0xdd, offset 0x3740 0x3742: 0x0008, 0x3743: 0x0008, 0x3744: 0x0008, 0x3751: 0x0008, 0x3752: 0x0008, 0x3753: 0x0008, 0x375c: 0x0008, 0x375d: 0x0008, 0x375e: 0x0008, 0x3761: 0x0008, 0x3763: 0x0008, 0x3768: 0x0008, 0x376f: 0x0008, 0x3773: 0x0008, 0x377a: 0x0008, 0x377b: 0x0008, 0x377c: 0x0008, 0x377d: 0x0008, 0x377e: 0x0008, 0x377f: 0x0008, // Block 0xde, offset 0x3780 0x3780: 0x0008, 0x3781: 0x0008, 0x3782: 0x0008, 0x3783: 0x0008, 0x3784: 0x0008, 0x3785: 0x0008, 0x3786: 0x0008, 0x3787: 0x0008, 0x3788: 0x0008, 0x3789: 0x0008, 0x378a: 0x0008, 0x378b: 0x0008, 0x378c: 0x0008, 0x378d: 0x0008, 0x378e: 0x0008, 0x378f: 0x0008, // Block 0xdf, offset 0x37c0 0x37c0: 0x0008, 0x37c1: 0x0008, 0x37c2: 0x0008, 0x37c3: 0x0008, 0x37c4: 0x0008, 0x37c5: 0x0008, 0x37cb: 0x0008, 0x37cc: 0x0008, 0x37cd: 0x0008, 0x37ce: 0x0008, 0x37cf: 0x0008, 0x37d0: 0x0008, 0x37d1: 0x0008, 0x37d2: 0x0008, 0x37d5: 0x0008, 0x37d6: 0x0008, 0x37d7: 0x0008, 0x37d8: 0x0008, 0x37d9: 0x0008, 0x37da: 0x0008, 0x37db: 0x0008, 0x37dc: 0x0008, 0x37dd: 0x0008, 0x37de: 0x0008, 0x37df: 0x0008, 0x37e0: 0x0008, 0x37e1: 0x0008, 0x37e2: 0x0008, 0x37e3: 0x0008, 0x37e4: 0x0008, 0x37e5: 0x0008, 0x37e9: 0x0008, 0x37eb: 0x0008, 0x37ec: 0x0008, 0x37ed: 0x0008, 0x37ee: 0x0008, 0x37ef: 0x0008, 0x37f0: 0x0008, 0x37f3: 0x0008, 0x37f4: 0x0008, 0x37f5: 0x0008, 0x37f6: 0x0008, 0x37f7: 0x0008, 0x37f8: 0x0008, 0x37f9: 0x0008, 0x37fa: 0x0008, 0x37fb: 0x0008, 0x37fc: 0x0008, 0x37fd: 0x0008, 0x37fe: 0x0008, 0x37ff: 0x0008, // Block 0xe0, offset 0x3800 0x381a: 0x0008, 0x381b: 0x0008, 0x381c: 0x0008, 0x381d: 0x0008, 0x381e: 0x0008, 0x381f: 0x0008, 0x3820: 0x0008, 0x3821: 0x0008, 0x3822: 0x0008, 0x3823: 0x0008, 0x3824: 0x0008, 0x3825: 0x0008, 0x3826: 0x0008, 0x3827: 0x0008, 0x3828: 0x0008, 0x3829: 0x0008, 0x382a: 0x0008, 0x382b: 0x0008, 0x382c: 0x0008, 0x382d: 0x0008, 0x382e: 0x0008, 0x382f: 0x0008, 0x3830: 0x0008, 0x3831: 0x0008, 0x3832: 0x0008, 0x3833: 0x0008, 0x3834: 0x0008, 0x3835: 0x0008, 0x3836: 0x0008, 0x3837: 0x0008, 0x3838: 0x0008, 0x3839: 0x0008, 0x383a: 0x0008, 0x383b: 0x0008, 0x383c: 0x0008, 0x383d: 0x0008, 0x383e: 0x0008, 0x383f: 0x0008, // Block 0xe1, offset 0x3840 0x384c: 0x0008, 0x384d: 0x0008, 0x384e: 0x0008, 0x384f: 0x0008, // Block 0xe2, offset 0x3880 0x3888: 0x0008, 0x3889: 0x0008, 0x388a: 0x0008, 0x388b: 0x0008, 0x388c: 0x0008, 0x388d: 0x0008, 0x388e: 0x0008, 0x388f: 0x0008, 0x389a: 0x0008, 0x389b: 0x0008, 0x389c: 0x0008, 0x389d: 0x0008, 0x389e: 0x0008, 0x389f: 0x0008, // Block 0xe3, offset 0x38c0 0x38c8: 0x0008, 0x38c9: 0x0008, 0x38ca: 0x0008, 0x38cb: 0x0008, 0x38cc: 0x0008, 0x38cd: 0x0008, 0x38ce: 0x0008, 0x38cf: 0x0008, 0x38ee: 0x0008, 0x38ef: 0x0008, 0x38fc: 0x0008, 0x38fd: 0x0008, 0x38fe: 0x0008, 0x38ff: 0x0008, // Block 0xe4, offset 0x3900 0x3902: 0x0008, 0x3903: 0x0008, 0x3904: 0x0008, 0x3905: 0x0008, 0x3906: 0x0008, 0x3907: 0x0008, 0x3908: 0x0008, 0x3909: 0x0008, 0x390a: 0x0008, 0x390b: 0x0008, 0x390c: 0x0008, 0x390d: 0x0008, 0x390e: 0x0008, 0x390f: 0x0008, 0x3919: 0x0008, 0x391a: 0x0008, 0x391b: 0x0008, 0x391c: 0x0008, 0x391d: 0x0008, 0x391e: 0x0008, 0x391f: 0x0008, 0x3920: 0x0008, 0x3921: 0x0008, 0x3922: 0x0008, 0x3923: 0x0008, 0x3924: 0x0008, 0x3925: 0x0008, 0x3926: 0x0008, 0x3927: 0x0008, 0x3928: 0x0008, 0x3929: 0x0008, 0x392a: 0x0008, 0x392b: 0x0008, 0x392c: 0x0008, 0x392d: 0x0008, 0x392e: 0x0008, 0x392f: 0x0008, 0x3930: 0x0008, 0x3931: 0x0008, 0x3932: 0x0008, 0x3933: 0x0008, 0x3934: 0x0008, 0x3935: 0x0008, 0x3936: 0x0008, 0x3937: 0x0008, 0x3938: 0x0008, 0x3939: 0x0008, 0x393a: 0x0008, 0x393b: 0x0008, 0x393c: 0x0008, 0x393d: 0x0008, 0x393e: 0x0008, 0x393f: 0x0008, // Block 0xe5, offset 0x3940 0x394c: 0x0008, 0x394d: 0x0008, 0x394e: 0x0008, 0x394f: 0x0008, 0x3950: 0x0008, 0x3951: 0x0008, 0x3952: 0x0008, 0x3953: 0x0008, 0x3954: 0x0008, 0x3955: 0x0008, 0x3956: 0x0008, 0x3957: 0x0008, 0x3958: 0x0008, 0x3959: 0x0008, 0x395a: 0x0008, 0x395b: 0x0008, 0x395c: 0x0008, 0x395d: 0x0008, 0x395e: 0x0008, 0x395f: 0x0008, 0x3960: 0x0008, 0x3961: 0x0008, 0x3962: 0x0008, 0x3963: 0x0008, 0x3964: 0x0008, 0x3965: 0x0008, 0x3966: 0x0008, 0x3967: 0x0008, 0x3968: 0x0008, 0x3969: 0x0008, 0x396a: 0x0008, 0x396b: 0x0008, 0x396c: 0x0008, 0x396d: 0x0008, 0x396e: 0x0008, 0x396f: 0x0008, 0x3970: 0x0008, 0x3971: 0x0008, 0x3972: 0x0008, 0x3973: 0x0008, 0x3974: 0x0008, 0x3975: 0x0008, 0x3976: 0x0008, 0x3977: 0x0008, 0x3978: 0x0008, 0x3979: 0x0008, 0x397a: 0x0008, 0x397c: 0x0008, 0x397d: 0x0008, 0x397e: 0x0008, 0x397f: 0x0008, // Block 0xe6, offset 0x3980 0x3980: 0x0008, 0x3981: 0x0008, 0x3982: 0x0008, 0x3983: 0x0008, 0x3984: 0x0008, 0x3985: 0x0008, 0x3987: 0x0008, 0x3988: 0x0008, 0x3989: 0x0008, 0x398a: 0x0008, 0x398b: 0x0008, 0x398c: 0x0008, 0x398d: 0x0008, 0x398e: 0x0008, 0x398f: 0x0008, 0x3990: 0x0008, 0x3991: 0x0008, 0x3992: 0x0008, 0x3993: 0x0008, 0x3994: 0x0008, 0x3995: 0x0008, 0x3996: 0x0008, 0x3997: 0x0008, 0x3998: 0x0008, 0x3999: 0x0008, 0x399a: 0x0008, 0x399b: 0x0008, 0x399c: 0x0008, 0x399d: 0x0008, 0x399e: 0x0008, 0x399f: 0x0008, 0x39a0: 0x0008, 0x39a1: 0x0008, 0x39a2: 0x0008, 0x39a3: 0x0008, 0x39a4: 0x0008, 0x39a5: 0x0008, 0x39a6: 0x0008, 0x39a7: 0x0008, 0x39a8: 0x0008, 0x39a9: 0x0008, 0x39aa: 0x0008, 0x39ab: 0x0008, 0x39ac: 0x0008, 0x39ad: 0x0008, 0x39ae: 0x0008, 0x39af: 0x0008, 0x39b0: 0x0008, 0x39b1: 0x0008, 0x39b2: 0x0008, 0x39b3: 0x0008, 0x39b4: 0x0008, 0x39b5: 0x0008, 0x39b6: 0x0008, 0x39b7: 0x0008, 0x39b8: 0x0008, 0x39b9: 0x0008, 0x39ba: 0x0008, 0x39bb: 0x0008, 0x39bc: 0x0008, 0x39bd: 0x0008, 0x39be: 0x0008, 0x39bf: 0x0008, // Block 0xe7, offset 0x39c0 0x39d8: 0x0008, 0x39d9: 0x0008, 0x39da: 0x0008, 0x39db: 0x0008, 0x39dc: 0x0008, 0x39dd: 0x0008, 0x39de: 0x0008, 0x39df: 0x0008, 0x39ee: 0x0008, 0x39ef: 0x0008, 0x39f0: 0x0008, 0x39f1: 0x0008, 0x39f2: 0x0008, 0x39f3: 0x0008, 0x39f4: 0x0008, 0x39f5: 0x0008, 0x39f6: 0x0008, 0x39f7: 0x0008, 0x39f8: 0x0008, 0x39f9: 0x0008, 0x39fa: 0x0008, 0x39fb: 0x0008, 0x39fc: 0x0008, 0x39fd: 0x0008, 0x39fe: 0x0008, 0x39ff: 0x0008, // Block 0xe8, offset 0x3a00 0x3a00: 0x0002, 0x3a01: 0x0002, 0x3a02: 0x0002, 0x3a03: 0x0002, 0x3a04: 0x0002, 0x3a05: 0x0002, 0x3a06: 0x0002, 0x3a07: 0x0002, 0x3a08: 0x0002, 0x3a09: 0x0002, 0x3a0a: 0x0002, 0x3a0b: 0x0002, 0x3a0c: 0x0002, 0x3a0d: 0x0002, 0x3a0e: 0x0002, 0x3a0f: 0x0002, 0x3a10: 0x0002, 0x3a11: 0x0002, 0x3a12: 0x0002, 0x3a13: 0x0002, 0x3a14: 0x0002, 0x3a15: 0x0002, 0x3a16: 0x0002, 0x3a17: 0x0002, 0x3a18: 0x0002, 0x3a19: 0x0002, 0x3a1a: 0x0002, 0x3a1b: 0x0002, 0x3a1c: 0x0002, 0x3a1d: 0x0002, 0x3a1e: 0x0002, 0x3a1f: 0x0002, 0x3a20: 0x0024, 0x3a21: 0x0024, 0x3a22: 0x0024, 0x3a23: 0x0024, 0x3a24: 0x0024, 0x3a25: 0x0024, 0x3a26: 0x0024, 0x3a27: 0x0024, 0x3a28: 0x0024, 0x3a29: 0x0024, 0x3a2a: 0x0024, 0x3a2b: 0x0024, 0x3a2c: 0x0024, 0x3a2d: 0x0024, 0x3a2e: 0x0024, 0x3a2f: 0x0024, 0x3a30: 0x0024, 0x3a31: 0x0024, 0x3a32: 0x0024, 0x3a33: 0x0024, 0x3a34: 0x0024, 0x3a35: 0x0024, 0x3a36: 0x0024, 0x3a37: 0x0024, 0x3a38: 0x0024, 0x3a39: 0x0024, 0x3a3a: 0x0024, 0x3a3b: 0x0024, 0x3a3c: 0x0024, 0x3a3d: 0x0024, 0x3a3e: 0x0024, 0x3a3f: 0x0024, // Block 0xe9, offset 0x3a40 0x3a40: 0x0002, 0x3a41: 0x0002, 0x3a42: 0x0002, 0x3a43: 0x0002, 0x3a44: 0x0002, 0x3a45: 0x0002, 0x3a46: 0x0002, 0x3a47: 0x0002, 0x3a48: 0x0002, 0x3a49: 0x0002, 0x3a4a: 0x0002, 0x3a4b: 0x0002, 0x3a4c: 0x0002, 0x3a4d: 0x0002, 0x3a4e: 0x0002, 0x3a4f: 0x0002, 0x3a50: 0x0002, 0x3a51: 0x0002, 0x3a52: 0x0002, 0x3a53: 0x0002, 0x3a54: 0x0002, 0x3a55: 0x0002, 0x3a56: 0x0002, 0x3a57: 0x0002, 0x3a58: 0x0002, 0x3a59: 0x0002, 0x3a5a: 0x0002, 0x3a5b: 0x0002, 0x3a5c: 0x0002, 0x3a5d: 0x0002, 0x3a5e: 0x0002, 0x3a5f: 0x0002, 0x3a60: 0x0002, 0x3a61: 0x0002, 0x3a62: 0x0002, 0x3a63: 0x0002, 0x3a64: 0x0002, 0x3a65: 0x0002, 0x3a66: 0x0002, 0x3a67: 0x0002, 0x3a68: 0x0002, 0x3a69: 0x0002, 0x3a6a: 0x0002, 0x3a6b: 0x0002, 0x3a6c: 0x0002, 0x3a6d: 0x0002, 0x3a6e: 0x0002, 0x3a6f: 0x0002, 0x3a70: 0x0002, 0x3a71: 0x0002, 0x3a72: 0x0002, 0x3a73: 0x0002, 0x3a74: 0x0002, 0x3a75: 0x0002, 0x3a76: 0x0002, 0x3a77: 0x0002, 0x3a78: 0x0002, 0x3a79: 0x0002, 0x3a7a: 0x0002, 0x3a7b: 0x0002, 0x3a7c: 0x0002, 0x3a7d: 0x0002, 0x3a7e: 0x0002, 0x3a7f: 0x0002, // Block 0xea, offset 0x3a80 0x3a80: 0x0024, 0x3a81: 0x0024, 0x3a82: 0x0024, 0x3a83: 0x0024, 0x3a84: 0x0024, 0x3a85: 0x0024, 0x3a86: 0x0024, 0x3a87: 0x0024, 0x3a88: 0x0024, 0x3a89: 0x0024, 0x3a8a: 0x0024, 0x3a8b: 0x0024, 0x3a8c: 0x0024, 0x3a8d: 0x0024, 0x3a8e: 0x0024, 0x3a8f: 0x0024, 0x3a90: 0x0024, 0x3a91: 0x0024, 0x3a92: 0x0024, 0x3a93: 0x0024, 0x3a94: 0x0024, 0x3a95: 0x0024, 0x3a96: 0x0024, 0x3a97: 0x0024, 0x3a98: 0x0024, 0x3a99: 0x0024, 0x3a9a: 0x0024, 0x3a9b: 0x0024, 0x3a9c: 0x0024, 0x3a9d: 0x0024, 0x3a9e: 0x0024, 0x3a9f: 0x0024, 0x3aa0: 0x0024, 0x3aa1: 0x0024, 0x3aa2: 0x0024, 0x3aa3: 0x0024, 0x3aa4: 0x0024, 0x3aa5: 0x0024, 0x3aa6: 0x0024, 0x3aa7: 0x0024, 0x3aa8: 0x0024, 0x3aa9: 0x0024, 0x3aaa: 0x0024, 0x3aab: 0x0024, 0x3aac: 0x0024, 0x3aad: 0x0024, 0x3aae: 0x0024, 0x3aaf: 0x0024, 0x3ab0: 0x0002, 0x3ab1: 0x0002, 0x3ab2: 0x0002, 0x3ab3: 0x0002, 0x3ab4: 0x0002, 0x3ab5: 0x0002, 0x3ab6: 0x0002, 0x3ab7: 0x0002, 0x3ab8: 0x0002, 0x3ab9: 0x0002, 0x3aba: 0x0002, 0x3abb: 0x0002, 0x3abc: 0x0002, 0x3abd: 0x0002, 0x3abe: 0x0002, 0x3abf: 0x0002, } // graphemesIndex: 25 blocks, 1600 entries, 1600 bytes // Block 0 is the zero block. var graphemesIndex = [1600]property{ // Block 0x0, offset 0x0 // Block 0x1, offset 0x40 // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc2: 0x01, 0xcc: 0x02, 0xcd: 0x03, 0xd2: 0x04, 0xd6: 0x05, 0xd7: 0x06, 0xd8: 0x07, 0xd9: 0x08, 0xdb: 0x09, 0xdc: 0x0a, 0xdd: 0x0b, 0xde: 0x0c, 0xdf: 0x0d, 0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xea: 0x06, 0xeb: 0x07, 0xec: 0x08, 0xed: 0x09, 0xef: 0x0a, 0xf0: 0x14, 0xf3: 0x16, // Block 0x4, offset 0x100 0x120: 0x0e, 0x121: 0x0f, 0x122: 0x10, 0x123: 0x11, 0x124: 0x12, 0x125: 0x13, 0x126: 0x14, 0x127: 0x15, 0x128: 0x16, 0x129: 0x17, 0x12a: 0x18, 0x12b: 0x19, 0x12c: 0x1a, 0x12d: 0x1b, 0x12e: 0x1c, 0x12f: 0x1d, 0x130: 0x1e, 0x131: 0x1f, 0x132: 0x20, 0x133: 0x21, 0x134: 0x22, 0x135: 0x23, 0x136: 0x24, 0x137: 0x25, 0x138: 0x26, 0x139: 0x27, 0x13a: 0x28, 0x13b: 0x29, 0x13c: 0x2a, 0x13d: 0x2b, 0x13e: 0x2c, 0x13f: 0x2d, // Block 0x5, offset 0x140 0x140: 0x2e, 0x141: 0x2f, 0x142: 0x30, 0x144: 0x31, 0x145: 0x32, 0x146: 0x33, 0x147: 0x34, 0x14d: 0x35, 0x15c: 0x36, 0x15d: 0x37, 0x15e: 0x38, 0x15f: 0x39, 0x160: 0x3a, 0x162: 0x3b, 0x164: 0x3c, 0x168: 0x3d, 0x169: 0x3e, 0x16a: 0x3f, 0x16b: 0x40, 0x16c: 0x41, 0x16d: 0x42, 0x16e: 0x43, 0x16f: 0x44, 0x170: 0x45, 0x173: 0x46, 0x177: 0x02, // Block 0x6, offset 0x180 0x180: 0x47, 0x181: 0x48, 0x183: 0x49, 0x184: 0x4a, 0x186: 0x4b, 0x18c: 0x4c, 0x18f: 0x4d, 0x193: 0x4e, 0x196: 0x4f, 0x197: 0x50, 0x198: 0x51, 0x199: 0x52, 0x19a: 0x53, 0x19b: 0x54, 0x19c: 0x55, 0x19d: 0x56, 0x19e: 0x57, 0x1a4: 0x58, 0x1ac: 0x59, 0x1ad: 0x5a, 0x1b3: 0x5b, 0x1b5: 0x5c, 0x1b7: 0x5d, // Block 0x7, offset 0x1c0 0x1c0: 0x5e, 0x1c2: 0x5f, 0x1ca: 0x60, // Block 0x8, offset 0x200 0x219: 0x61, 0x21a: 0x62, 0x21b: 0x63, 0x220: 0x64, 0x222: 0x65, 0x223: 0x66, 0x224: 0x67, 0x225: 0x68, 0x226: 0x69, 0x227: 0x6a, 0x228: 0x6b, 0x229: 0x6c, 0x22a: 0x6d, 0x22b: 0x6e, 0x22f: 0x6f, 0x230: 0x70, 0x231: 0x71, 0x232: 0x72, 0x233: 0x73, 0x234: 0x74, 0x235: 0x75, 0x236: 0x76, 0x237: 0x70, 0x238: 0x71, 0x239: 0x72, 0x23a: 0x73, 0x23b: 0x74, 0x23c: 0x75, 0x23d: 0x76, 0x23e: 0x70, 0x23f: 0x71, // Block 0x9, offset 0x240 0x240: 0x72, 0x241: 0x73, 0x242: 0x74, 0x243: 0x75, 0x244: 0x76, 0x245: 0x70, 0x246: 0x71, 0x247: 0x72, 0x248: 0x73, 0x249: 0x74, 0x24a: 0x75, 0x24b: 0x76, 0x24c: 0x70, 0x24d: 0x71, 0x24e: 0x72, 0x24f: 0x73, 0x250: 0x74, 0x251: 0x75, 0x252: 0x76, 0x253: 0x70, 0x254: 0x71, 0x255: 0x72, 0x256: 0x73, 0x257: 0x74, 0x258: 0x75, 0x259: 0x76, 0x25a: 0x70, 0x25b: 0x71, 0x25c: 0x72, 0x25d: 0x73, 0x25e: 0x74, 0x25f: 0x75, 0x260: 0x76, 0x261: 0x70, 0x262: 0x71, 0x263: 0x72, 0x264: 0x73, 0x265: 0x74, 0x266: 0x75, 0x267: 0x76, 0x268: 0x70, 0x269: 0x71, 0x26a: 0x72, 0x26b: 0x73, 0x26c: 0x74, 0x26d: 0x75, 0x26e: 0x76, 0x26f: 0x70, 0x270: 0x71, 0x271: 0x72, 0x272: 0x73, 0x273: 0x74, 0x274: 0x75, 0x275: 0x76, 0x276: 0x70, 0x277: 0x71, 0x278: 0x72, 0x279: 0x73, 0x27a: 0x74, 0x27b: 0x75, 0x27c: 0x76, 0x27d: 0x70, 0x27e: 0x71, 0x27f: 0x72, // Block 0xa, offset 0x280 0x280: 0x73, 0x281: 0x74, 0x282: 0x75, 0x283: 0x76, 0x284: 0x70, 0x285: 0x71, 0x286: 0x72, 0x287: 0x73, 0x288: 0x74, 0x289: 0x75, 0x28a: 0x76, 0x28b: 0x70, 0x28c: 0x71, 0x28d: 0x72, 0x28e: 0x73, 0x28f: 0x74, 0x290: 0x75, 0x291: 0x76, 0x292: 0x70, 0x293: 0x71, 0x294: 0x72, 0x295: 0x73, 0x296: 0x74, 0x297: 0x75, 0x298: 0x76, 0x299: 0x70, 0x29a: 0x71, 0x29b: 0x72, 0x29c: 0x73, 0x29d: 0x74, 0x29e: 0x75, 0x29f: 0x76, 0x2a0: 0x70, 0x2a1: 0x71, 0x2a2: 0x72, 0x2a3: 0x73, 0x2a4: 0x74, 0x2a5: 0x75, 0x2a6: 0x76, 0x2a7: 0x70, 0x2a8: 0x71, 0x2a9: 0x72, 0x2aa: 0x73, 0x2ab: 0x74, 0x2ac: 0x75, 0x2ad: 0x76, 0x2ae: 0x70, 0x2af: 0x71, 0x2b0: 0x72, 0x2b1: 0x73, 0x2b2: 0x74, 0x2b3: 0x75, 0x2b4: 0x76, 0x2b5: 0x70, 0x2b6: 0x71, 0x2b7: 0x72, 0x2b8: 0x73, 0x2b9: 0x74, 0x2ba: 0x75, 0x2bb: 0x76, 0x2bc: 0x70, 0x2bd: 0x71, 0x2be: 0x72, 0x2bf: 0x73, // Block 0xb, offset 0x2c0 0x2c0: 0x74, 0x2c1: 0x75, 0x2c2: 0x76, 0x2c3: 0x70, 0x2c4: 0x71, 0x2c5: 0x72, 0x2c6: 0x73, 0x2c7: 0x74, 0x2c8: 0x75, 0x2c9: 0x76, 0x2ca: 0x70, 0x2cb: 0x71, 0x2cc: 0x72, 0x2cd: 0x73, 0x2ce: 0x74, 0x2cf: 0x75, 0x2d0: 0x76, 0x2d1: 0x70, 0x2d2: 0x71, 0x2d3: 0x72, 0x2d4: 0x73, 0x2d5: 0x74, 0x2d6: 0x75, 0x2d7: 0x76, 0x2d8: 0x70, 0x2d9: 0x71, 0x2da: 0x72, 0x2db: 0x73, 0x2dc: 0x74, 0x2dd: 0x75, 0x2de: 0x77, 0x2df: 0x78, // Block 0xc, offset 0x300 0x32c: 0x79, 0x338: 0x7a, 0x33b: 0x7b, 0x33e: 0x62, 0x33f: 0x7c, // Block 0xd, offset 0x340 0x347: 0x7d, 0x34b: 0x7e, 0x34d: 0x7f, 0x368: 0x80, 0x36b: 0x81, 0x374: 0x82, 0x375: 0x83, 0x37a: 0x84, 0x37b: 0x85, 0x37d: 0x86, 0x37e: 0x87, // Block 0xe, offset 0x380 0x380: 0x88, 0x381: 0x89, 0x382: 0x8a, 0x383: 0x8b, 0x384: 0x8c, 0x385: 0x8d, 0x386: 0x8e, 0x387: 0x8f, 0x388: 0x90, 0x389: 0x91, 0x38b: 0x92, 0x38c: 0x93, 0x38d: 0x94, 0x38e: 0x95, 0x38f: 0x96, 0x390: 0x97, 0x391: 0x98, 0x392: 0x99, 0x393: 0x9a, 0x396: 0x9b, 0x397: 0x9c, 0x398: 0x9d, 0x399: 0x9e, 0x39a: 0x9f, 0x39c: 0xa0, 0x3a0: 0xa1, 0x3a4: 0xa2, 0x3a5: 0xa3, 0x3a7: 0xa4, 0x3a8: 0xa5, 0x3a9: 0xa6, 0x3aa: 0xa7, 0x3ad: 0xa8, 0x3b0: 0xa9, 0x3b2: 0xaa, 0x3b4: 0xab, 0x3b5: 0xac, 0x3b6: 0xad, 0x3bb: 0xae, 0x3bc: 0xaf, 0x3bd: 0xb0, // Block 0xf, offset 0x3c0 0x3d0: 0xb1, 0x3d1: 0xb2, // Block 0x10, offset 0x400 0x404: 0xb3, 0x42b: 0xb4, 0x42c: 0xb5, 0x435: 0xb6, 0x43d: 0xb7, 0x43e: 0xb8, 0x43f: 0xb9, // Block 0x11, offset 0x440 0x472: 0xba, // Block 0x12, offset 0x480 0x4bc: 0xbb, 0x4bd: 0xbc, // Block 0x13, offset 0x4c0 0x4c5: 0xbd, 0x4c6: 0xbe, 0x4c9: 0xbf, 0x4e8: 0xc0, 0x4e9: 0xc1, 0x4ea: 0xc2, // Block 0x14, offset 0x500 0x500: 0xc3, 0x502: 0xc4, 0x504: 0xb5, 0x50a: 0xc5, 0x50b: 0xc6, 0x513: 0xc6, 0x517: 0xc7, 0x51b: 0xc8, 0x523: 0xc9, 0x525: 0xca, // Block 0x15, offset 0x540 0x540: 0xcb, 0x542: 0xcc, 0x543: 0xcd, 0x545: 0xce, 0x546: 0xcf, 0x547: 0xd0, 0x548: 0xd1, 0x549: 0xd2, 0x54a: 0xd3, 0x54b: 0xd3, 0x54c: 0xd4, 0x54d: 0xd3, 0x54e: 0xd5, 0x54f: 0xd6, 0x550: 0xd3, 0x551: 0xd3, 0x552: 0xd3, 0x553: 0xd7, 0x554: 0xd8, 0x555: 0xd9, 0x556: 0xda, 0x557: 0xdb, 0x558: 0xd3, 0x559: 0xdc, 0x55a: 0xd3, 0x55b: 0xdd, 0x55f: 0xde, 0x560: 0xdf, 0x561: 0xe0, 0x562: 0xe1, 0x563: 0xe2, 0x564: 0xe3, 0x565: 0xe4, 0x566: 0xd3, 0x567: 0xd3, 0x569: 0xe5, 0x56a: 0xd3, 0x56b: 0xd3, 0x570: 0xd3, 0x571: 0xd3, 0x572: 0xd3, 0x573: 0xd3, 0x574: 0xd3, 0x575: 0xd3, 0x576: 0xd3, 0x577: 0xd3, 0x578: 0xd3, 0x579: 0xd3, 0x57a: 0xd3, 0x57b: 0xd3, 0x57c: 0xd3, 0x57d: 0xd3, 0x57e: 0xd3, 0x57f: 0xd8, // Block 0x16, offset 0x580 0x590: 0x0b, 0x591: 0x0c, 0x593: 0x0d, 0x596: 0x0e, 0x59b: 0x0f, 0x59c: 0x10, 0x59d: 0x11, 0x59e: 0x12, 0x59f: 0x13, // Block 0x17, offset 0x5c0 0x5c0: 0xe6, 0x5c1: 0x02, 0x5c2: 0xe7, 0x5c3: 0xe7, 0x5c4: 0x02, 0x5c5: 0x02, 0x5c6: 0x02, 0x5c7: 0xe8, 0x5c8: 0xe7, 0x5c9: 0xe7, 0x5ca: 0xe7, 0x5cb: 0xe7, 0x5cc: 0xe7, 0x5cd: 0xe7, 0x5ce: 0xe7, 0x5cf: 0xe7, 0x5d0: 0xe7, 0x5d1: 0xe7, 0x5d2: 0xe7, 0x5d3: 0xe7, 0x5d4: 0xe7, 0x5d5: 0xe7, 0x5d6: 0xe7, 0x5d7: 0xe7, 0x5d8: 0xe7, 0x5d9: 0xe7, 0x5da: 0xe7, 0x5db: 0xe7, 0x5dc: 0xe7, 0x5dd: 0xe7, 0x5de: 0xe7, 0x5df: 0xe7, 0x5e0: 0xe7, 0x5e1: 0xe7, 0x5e2: 0xe7, 0x5e3: 0xe7, 0x5e4: 0xe7, 0x5e5: 0xe7, 0x5e6: 0xe7, 0x5e7: 0xe7, 0x5e8: 0xe7, 0x5e9: 0xe7, 0x5ea: 0xe7, 0x5eb: 0xe7, 0x5ec: 0xe7, 0x5ed: 0xe7, 0x5ee: 0xe7, 0x5ef: 0xe7, 0x5f0: 0xe7, 0x5f1: 0xe7, 0x5f2: 0xe7, 0x5f3: 0xe7, 0x5f4: 0xe7, 0x5f5: 0xe7, 0x5f6: 0xe7, 0x5f7: 0xe7, 0x5f8: 0xe7, 0x5f9: 0xe7, 0x5fa: 0xe7, 0x5fb: 0xe7, 0x5fc: 0xe7, 0x5fd: 0xe7, 0x5fe: 0xe7, 0x5ff: 0xe7, // Block 0x18, offset 0x600 0x620: 0x15, } golang-github-clipperhouse-uax29-2.7.0/graphemes/unicode_test.go000066400000000000000000006405551515045622700247320ustar00rootroot00000000000000package graphemes_test // generated by github.com/clipperhouse/uax29/v2 // from https://www.unicode.org/Public/17.0.0/ucd/auxiliary/GraphemeBreakTest.txt type unicodeTest struct { input []byte expected [][]byte comment string } var unicodeTests = [766]unicodeTest{ { input: []byte{0xd, 0xd}, expected: [][]byte{{0xd}, {0xd}}, comment: "÷ [0.2] (CR) ÷ [4.0] (CR) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xd, 0xa}, expected: [][]byte{{0xd, 0xa}}, comment: "÷ [0.2] (CR) × [3.0] (LF) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xd, 0x0}, expected: [][]byte{{0xd}, {0x0}}, comment: "÷ [0.2] (CR) ÷ [4.0] (Control) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xd, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xd}, {0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] (CR) ÷ [4.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x80}, expected: [][]byte{{0xd}, {0xcc, 0x80}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xd, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xd}, {0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] (CR) ÷ [4.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xd, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xd}, {0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (CR) ÷ [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xd, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xd}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (CR) ÷ [4.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xd, 0xdb, 0x9d}, expected: [][]byte{{0xd}, {0xdb, 0x9d}}, comment: "÷ [0.2] (CR) ÷ [4.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xd, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xd}, {0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] (CR) ÷ [4.0] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xd, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xd}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] (CR) ÷ [4.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xd, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xd}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] (CR) ÷ [4.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xd, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xd}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] (CR) ÷ [4.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xd, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xd}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] (CR) ÷ [4.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xd, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xd}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] (CR) ÷ [4.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xd, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xd}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] (CR) ÷ [4.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xd, 0xc2, 0xa9}, expected: [][]byte{{0xd}, {0xc2, 0xa9}}, comment: "÷ [0.2] (CR) ÷ [4.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0x20}, expected: [][]byte{{0xd}, {0x20}}, comment: "÷ [0.2] (CR) ÷ [4.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0xcd, 0xb8}, expected: [][]byte{{0xd}, {0xcd, 0xb8}}, comment: "÷ [0.2] (CR) ÷ [4.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0xd}, expected: [][]byte{{0xa}, {0xd}}, comment: "÷ [0.2] (LF) ÷ [4.0] (CR) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xa, 0xa}, expected: [][]byte{{0xa}, {0xa}}, comment: "÷ [0.2] (LF) ÷ [4.0] (LF) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xa, 0x0}, expected: [][]byte{{0xa}, {0x0}}, comment: "÷ [0.2] (LF) ÷ [4.0] (Control) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xa, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xa}, {0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] (LF) ÷ [4.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x80}, expected: [][]byte{{0xa}, {0xcc, 0x80}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xa, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xa}, {0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] (LF) ÷ [4.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xa, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xa}, {0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (LF) ÷ [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xa, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xa}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (LF) ÷ [4.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xa, 0xdb, 0x9d}, expected: [][]byte{{0xa}, {0xdb, 0x9d}}, comment: "÷ [0.2] (LF) ÷ [4.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xa, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xa}, {0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] (LF) ÷ [4.0] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xa, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xa}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] (LF) ÷ [4.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xa, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xa}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] (LF) ÷ [4.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xa, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xa}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] (LF) ÷ [4.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xa, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xa}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] (LF) ÷ [4.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xa, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xa}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] (LF) ÷ [4.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xa, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xa}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] (LF) ÷ [4.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xa, 0xc2, 0xa9}, expected: [][]byte{{0xa}, {0xc2, 0xa9}}, comment: "÷ [0.2] (LF) ÷ [4.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0x20}, expected: [][]byte{{0xa}, {0x20}}, comment: "÷ [0.2] (LF) ÷ [4.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0xcd, 0xb8}, expected: [][]byte{{0xa}, {0xcd, 0xb8}}, comment: "÷ [0.2] (LF) ÷ [4.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0xd}, expected: [][]byte{{0x0}, {0xd}}, comment: "÷ [0.2] (Control) ÷ [4.0] (CR) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0x0, 0xa}, expected: [][]byte{{0x0}, {0xa}}, comment: "÷ [0.2] (Control) ÷ [4.0] (LF) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0x0, 0x0}, expected: [][]byte{{0x0}, {0x0}}, comment: "÷ [0.2] (Control) ÷ [4.0] (Control) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0x0, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0x0}, {0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] (Control) ÷ [4.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0x0}, {0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x80}, expected: [][]byte{{0x0}, {0xcc, 0x80}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x0}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0x0, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0x0}, {0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] (Control) ÷ [4.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0x0}, {0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0x0, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x0}, {0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (Control) ÷ [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x0}, {0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x0, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x0}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (Control) ÷ [4.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x0, 0xdb, 0x9d}, expected: [][]byte{{0x0}, {0xdb, 0x9d}}, comment: "÷ [0.2] (Control) ÷ [4.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0x0, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0x0}, {0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] (Control) ÷ [4.0] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0x0}, {0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0x0, 0xe1, 0x84, 0x80}, expected: [][]byte{{0x0}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] (Control) ÷ [4.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0x0, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0x0}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] (Control) ÷ [4.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0x0, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0x0}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] (Control) ÷ [4.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0x0, 0xea, 0xb0, 0x80}, expected: [][]byte{{0x0}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] (Control) ÷ [4.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0x0, 0xea, 0xb0, 0x81}, expected: [][]byte{{0x0}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] (Control) ÷ [4.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0x0, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0x0}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] (Control) ÷ [4.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0x0, 0xc2, 0xa9}, expected: [][]byte{{0x0}, {0xc2, 0xa9}}, comment: "÷ [0.2] (Control) ÷ [4.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0x20}, expected: [][]byte{{0x0}, {0x20}}, comment: "÷ [0.2] (Control) ÷ [4.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0xcd, 0xb8}, expected: [][]byte{{0x0}, {0xcd, 0xb8}}, comment: "÷ [0.2] (Control) ÷ [4.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0x0}, {0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] (Control) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xd}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xd}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xa}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xa}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0x0}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0x0}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x80}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xdb, 0x9d}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xdb, 0x9d}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xc2, 0xa9}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xc2, 0xa9}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0x20}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0x20}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcd, 0xb8}, expected: [][]byte{{0xe0, 0xa5, 0x8d}, {0xcd, 0xb8}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa5, 0x8d, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xe0, 0xa5, 0x8d, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xd}, expected: [][]byte{{0xcc, 0x80}, {0xd}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xa}, expected: [][]byte{{0xcc, 0x80}, {0xa}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x0}, expected: [][]byte{{0xcc, 0x80}, {0x0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xcc, 0x80, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x80}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xcc, 0x80, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xcc, 0x80, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xcc, 0x80}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xdb, 0x9d}, expected: [][]byte{{0xcc, 0x80}, {0xdb, 0x9d}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xcc, 0x80, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xcc, 0x80}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xcc, 0x80}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xcc, 0x80}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xcc, 0x80}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xcc, 0x80}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xcc, 0x80}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xc2, 0xa9}, expected: [][]byte{{0xcc, 0x80}, {0xc2, 0xa9}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x20}, expected: [][]byte{{0xcc, 0x80}, {0x20}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcd, 0xb8}, expected: [][]byte{{0xcc, 0x80}, {0xcd, 0xb8}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xd}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xd}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xa}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xa}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0x0}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0x0}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x80}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xdb, 0x9d}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xdb, 0x9d}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xc2, 0xa9}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xc2, 0xa9}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0x20}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0x20}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcd, 0xb8}, expected: [][]byte{{0xe2, 0x80, 0x8c}, {0xcd, 0xb8}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8c, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xe2, 0x80, 0x8c, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xd}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xd}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xa}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xa}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x0}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x80}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xdb, 0x9d}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xdb, 0x9d}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xc2, 0xa9}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xc2, 0xa9}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x20}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x20}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcd, 0xb8}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xcd, 0xb8}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xd}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xd}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xa}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xa}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x80}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x80}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [12.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xdb, 0x9d}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xdb, 0x9d}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xc2, 0xa9}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xc2, 0xa9}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x20}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x20}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcd, 0xb8}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xcd, 0xb8}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xd}, expected: [][]byte{{0xdb, 0x9d}, {0xd}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xa}, expected: [][]byte{{0xdb, 0x9d}, {0xa}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0x0}, expected: [][]byte{{0xdb, 0x9d}, {0x0}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xdb, 0x9d, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x80}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x80}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xdb, 0x9d, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xdb, 0x9d, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xdb, 0x9d, 0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xdb, 0x9d}, expected: [][]byte{{0xdb, 0x9d, 0xdb, 0x9d}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xdb, 0x9d, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xdb, 0x9d, 0xe1, 0x84, 0x80}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xdb, 0x9d, 0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xdb, 0x9d, 0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xdb, 0x9d, 0xea, 0xb0, 0x80}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xdb, 0x9d, 0xea, 0xb0, 0x81}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xdb, 0x9d, 0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xc2, 0xa9}, expected: [][]byte{{0xdb, 0x9d, 0xc2, 0xa9}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0x20}, expected: [][]byte{{0xdb, 0x9d, 0x20}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcd, 0xb8}, expected: [][]byte{{0xdb, 0x9d, 0xcd, 0xb8}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.2] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xdb, 0x9d, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xdb, 0x9d, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] ARABIC END OF AYAH (Prepend) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xd}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xd}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xa}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xa}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0x0}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0x0}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xdb, 0x9d}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xdb, 0x9d}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xc2, 0xa9}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xc2, 0xa9}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0x20}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0x20}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcd, 0xb8}, expected: [][]byte{{0xe0, 0xa4, 0x83}, {0xcd, 0xb8}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x83, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xe0, 0xa4, 0x83, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] DEVANAGARI SIGN VISARGA (SpacingMark) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xd}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0xd}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xa}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0xa}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0x0}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0x0}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x80}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xdb, 0x9d}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [6.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [6.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [6.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [6.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xc2, 0xa9}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0x20}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0x20}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcd, 0xb8}, expected: [][]byte{{0xe1, 0x84, 0x80}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xd}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xd}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xa}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xa}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0x0}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0x0}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x80}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xdb, 0x9d}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [7.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [7.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xc2, 0xa9}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0x20}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0x20}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcd, 0xb8}, expected: [][]byte{{0xe1, 0x85, 0xa0}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x85, 0xa0, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xe1, 0x85, 0xa0, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL JUNGSEONG FILLER (V) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xd}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xd}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xa}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xa}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0x0}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0x0}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x80}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xdb, 0x9d}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [8.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xc2, 0xa9}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0x20}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0x20}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcd, 0xb8}, expected: [][]byte{{0xe1, 0x86, 0xa8}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x86, 0xa8, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xe1, 0x86, 0xa8, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL JONGSEONG KIYEOK (T) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xd}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xd}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xa}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xa}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0x0}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0x0}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xdb, 0x9d}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [7.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [7.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xc2, 0xa9}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0x20}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0x20}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcd, 0xb8}, expected: [][]byte{{0xea, 0xb0, 0x80}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xd}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xd}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xa}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xa}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0x0}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0x0}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xdb, 0x9d}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [8.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xc2, 0xa9}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0x20}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0x20}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcd, 0xb8}, expected: [][]byte{{0xea, 0xb0, 0x81}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xd}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xd}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xa}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xa}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0x0}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0x0}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x80}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xdb, 0x9d}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xdb, 0x9d}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xc2, 0xa9}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xc2, 0xa9}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0x20}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0x20}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcd, 0xb8}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xcd, 0xb8}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xd}, expected: [][]byte{{0xc2, 0xa9}, {0xd}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xa}, expected: [][]byte{{0xc2, 0xa9}, {0xa}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x0}, expected: [][]byte{{0xc2, 0xa9}, {0x0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xc2, 0xa9, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x80}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xc2, 0xa9, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xc2, 0xa9, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xc2, 0xa9}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xdb, 0x9d}, expected: [][]byte{{0xc2, 0xa9}, {0xdb, 0x9d}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xc2, 0xa9, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xc2, 0xa9}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xc2, 0xa9}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xc2, 0xa9}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xc2, 0xa9}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xc2, 0xa9}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xc2, 0xa9}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xc2, 0xa9}, expected: [][]byte{{0xc2, 0xa9}, {0xc2, 0xa9}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x20}, expected: [][]byte{{0xc2, 0xa9}, {0x20}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcd, 0xb8}, expected: [][]byte{{0xc2, 0xa9}, {0xcd, 0xb8}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0xd}, expected: [][]byte{{0x20}, {0xd}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0x20, 0xa}, expected: [][]byte{{0x20}, {0xa}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0x20, 0x0}, expected: [][]byte{{0x20}, {0x0}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0x20, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0x20, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0x20, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x80}, expected: [][]byte{{0x20, 0xcc, 0x80}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x20, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0x20, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0x20, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0x20, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0x20, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x20, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x20, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x20, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x20}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x20, 0xdb, 0x9d}, expected: [][]byte{{0x20}, {0xdb, 0x9d}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0x20, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0x20, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0x20, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0x20, 0xe1, 0x84, 0x80}, expected: [][]byte{{0x20}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0x20, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0x20}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0x20, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0x20}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0x20, 0xea, 0xb0, 0x80}, expected: [][]byte{{0x20}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0x20, 0xea, 0xb0, 0x81}, expected: [][]byte{{0x20}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0x20, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0x20}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0x20, 0xc2, 0xa9}, expected: [][]byte{{0x20}, {0xc2, 0xa9}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0x20}, expected: [][]byte{{0x20}, {0x20}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0xcd, 0xb8}, expected: [][]byte{{0x20}, {0xcd, 0xb8}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xd}, expected: [][]byte{{0xcd, 0xb8}, {0xd}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (CR) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xa}, expected: [][]byte{{0xcd, 0xb8}, {0xa}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (LF) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0x0}, expected: [][]byte{{0xcd, 0xb8}, {0x0}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [5.0] (Control) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xcd, 0xb8, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88, 0xe0, 0xa5, 0x8d}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x80}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x80}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING GRAVE ACCENT (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xcd, 0xb8, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xe2, 0x80, 0x8c}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88, 0xe2, 0x80, 0x8c}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH NON-JOINER (ExtendmConjunctLinkermConjunctExtender) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xcd, 0xb8, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xcd, 0xb8}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xdb, 0x9d}, expected: [][]byte{{0xcd, 0xb8}, {0xdb, 0x9d}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xdb, 0x9d}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xdb, 0x9d}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] ARABIC END OF AYAH (Prepend) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xcd, 0xb8, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xe0, 0xa4, 0x83}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88, 0xe0, 0xa4, 0x83}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xcd, 0xb8}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xcd, 0xb8}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xe1, 0x85, 0xa0}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xe1, 0x85, 0xa0}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JUNGSEONG FILLER (V) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xcd, 0xb8}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xe1, 0x86, 0xa8}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xe1, 0x86, 0xa8}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL JONGSEONG KIYEOK (T) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xcd, 0xb8}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xea, 0xb0, 0x80}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xea, 0xb0, 0x80}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GA (LV) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xcd, 0xb8}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xea, 0xb0, 0x81}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xea, 0xb0, 0x81}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] HANGUL SYLLABLE GAG (LVT) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xcd, 0xb8}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xe0, 0xa4, 0x95}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xe0, 0xa4, 0x95}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xc2, 0xa9}, expected: [][]byte{{0xcd, 0xb8}, {0xc2, 0xa9}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] COPYRIGHT SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0x20}, expected: [][]byte{{0xcd, 0xb8}, {0x20}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcd, 0xb8}, expected: [][]byte{{0xcd, 0xb8}, {0xcd, 0xb8}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xcd, 0xb8, 0xcc, 0x88, 0xcd, 0xb8}, expected: [][]byte{{0xcd, 0xb8, 0xcc, 0x88}, {0xcd, 0xb8}}, comment: "÷ [0.2] (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0xa, 0x61, 0xa, 0xcc, 0x88}, expected: [][]byte{{0xd, 0xa}, {0x61}, {0xa}, {0xcc, 0x88}}, comment: "÷ [0.2] (CR) × [3.0] (LF) ÷ [4.0] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) ÷ [5.0] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88}, expected: [][]byte{{0x61, 0xcc, 0x88}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0x20, 0xe2, 0x80, 0x8d, 0xd9, 0x86}, expected: [][]byte{{0x20, 0xe2, 0x80, 0x8d}, {0xd9, 0x86}}, comment: "÷ [0.2] SPACE (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] ARABIC LETTER NOON (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xd9, 0x86, 0xe2, 0x80, 0x8d, 0x20}, expected: [][]byte{{0xd9, 0x86, 0xe2, 0x80, 0x8d}, {0x20}}, comment: "÷ [0.2] ARABIC LETTER NOON (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] SPACE (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe1, 0x84, 0x80, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xe1, 0x84, 0x80, 0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL CHOSEONG KIYEOK (L) × [6.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x80, 0xe1, 0x86, 0xa8, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x80, 0xe1, 0x86, 0xa8}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GA (LV) × [7.0] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xea, 0xb0, 0x81, 0xe1, 0x86, 0xa8, 0xe1, 0x84, 0x80}, expected: [][]byte{{0xea, 0xb0, 0x81, 0xe1, 0x86, 0xa8}, {0xe1, 0x84, 0x80}}, comment: "÷ [0.2] HANGUL SYLLABLE GAG (LVT) × [8.0] HANGUL JONGSEONG KIYEOK (T) ÷ [999.0] HANGUL CHOSEONG KIYEOK (L) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8, 0x62}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7}, {0xf0, 0x9f, 0x87, 0xa8}, {0x62}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [12.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) ÷ [999.0] LATIN SMALL LETTER B (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8, 0x62}, expected: [][]byte{{0x61}, {0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7}, {0xf0, 0x9f, 0x87, 0xa8}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [13.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) ÷ [999.0] LATIN SMALL LETTER B (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x87, 0xa8, 0x62}, expected: [][]byte{{0x61}, {0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xe2, 0x80, 0x8d}, {0xf0, 0x9f, 0x87, 0xa8}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [13.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) ÷ [999.0] LATIN SMALL LETTER B (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8, 0x62}, expected: [][]byte{{0x61}, {0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8d}, {0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) × [13.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) ÷ [999.0] LATIN SMALL LETTER B (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8, 0xf0, 0x9f, 0x87, 0xa9, 0x62}, expected: [][]byte{{0x61}, {0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7}, {0xf0, 0x9f, 0x87, 0xa8, 0xf0, 0x9f, 0x87, 0xa9}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [13.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) × [13.0] REGIONAL INDICATOR SYMBOL LETTER D (RI) ÷ [999.0] LATIN SMALL LETTER B (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x62}, expected: [][]byte{{0x61, 0xcc, 0x88}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] LATIN SMALL LETTER B (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe0, 0xa4, 0x83, 0x62}, expected: [][]byte{{0x61, 0xe0, 0xa4, 0x83}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.1] DEVANAGARI SIGN VISARGA (SpacingMark) ÷ [999.0] LATIN SMALL LETTER B (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xd8, 0x80, 0x62}, expected: [][]byte{{0x61}, {0xd8, 0x80, 0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) ÷ [999.0] ARABIC NUMBER SIGN (Prepend) × [9.2] LATIN SMALL LETTER B (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf, 0xf0, 0x9f, 0x91, 0xb6}, expected: [][]byte{{0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf}, {0xf0, 0x9f, 0x91, 0xb6}}, comment: "÷ [0.2] BABY (ExtPict) × [9.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] BABY (ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x8f, 0xbf, 0xf0, 0x9f, 0x91, 0xb6}, expected: [][]byte{{0x61, 0xf0, 0x9f, 0x8f, 0xbf}, {0xf0, 0x9f, 0x91, 0xb6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] BABY (ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x8f, 0xbf, 0xf0, 0x9f, 0x91, 0xb6, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}, expected: [][]byte{{0x61, 0xf0, 0x9f, 0x8f, 0xbf}, {0xf0, 0x9f, 0x91, 0xb6, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] BABY (ExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) × [11.0] OCTAGONAL SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf, 0xcc, 0x88, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf}, expected: [][]byte{{0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf, 0xcc, 0x88, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf}}, comment: "÷ [0.2] BABY (ExtPict) × [9.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend_ConjunctExtendermConjunctLinker) × [9.0] COMBINING DIAERESIS (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) × [11.0] BABY (ExtPict) × [9.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x9b, 0x91, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}, expected: [][]byte{{0xf0, 0x9f, 0x9b, 0x91, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}}, comment: "÷ [0.2] OCTAGONAL SIGN (ExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) × [11.0] OCTAGONAL SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}, expected: [][]byte{{0x61, 0xe2, 0x80, 0x8d}, {0xf0, 0x9f, 0x9b, 0x91}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] OCTAGONAL SIGN (ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x9c, 0x81, 0xe2, 0x80, 0x8d, 0xe2, 0x9c, 0x81}, expected: [][]byte{{0xe2, 0x9c, 0x81, 0xe2, 0x80, 0x8d}, {0xe2, 0x9c, 0x81}}, comment: "÷ [0.2] UPPER BLADE SCISSORS (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] UPPER BLADE SCISSORS (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x80, 0x8d, 0xe2, 0x9c, 0x81}, expected: [][]byte{{0x61, 0xe2, 0x80, 0x8d}, {0xe2, 0x9c, 0x81}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] UPPER BLADE SCISSORS (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0xe0, 0xa4, 0x95}, {0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) ÷ [999.0] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe2, 0x80, 0x8d, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe2, 0x80, 0x8d, 0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) × [9.3] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbc, 0xe2, 0x80, 0x8d, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbc, 0xe2, 0x80, 0x8d, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN NUKTA (Extend_ConjunctExtendermConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbc, 0xe0, 0xa5, 0x8d, 0xe2, 0x80, 0x8d, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbc, 0xe0, 0xa5, 0x8d, 0xe2, 0x80, 0x8d, 0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN NUKTA (Extend_ConjunctExtendermConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] ZERO WIDTH JOINER (ZWJ) × [9.3] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] DEVANAGARI LETTER TA (LinkingConsonant) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] DEVANAGARI LETTER YA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0x61}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d}, {0x61}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0x61, 0xe0, 0xa5, 0x8d}, {0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] LATIN SMALL LETTER A (XXmLinkingConsonantmExtPict) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0x3f, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0x3f, 0xe0, 0xa5, 0x8d}, {0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] QUESTION MARK (XXmLinkingConsonantmExtPict) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) ÷ [999.0] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}, expected: [][]byte{{0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4}}, comment: "÷ [0.2] DEVANAGARI LETTER KA (LinkingConsonant) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.0] DEVANAGARI SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] DEVANAGARI LETTER TA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe0, 0xaa, 0xb8, 0xe0, 0xab, 0xbb, 0xe0, 0xab, 0x8d, 0xe0, 0xaa, 0xb8, 0xe0, 0xab, 0xbb}, expected: [][]byte{{0xe0, 0xaa, 0xb8, 0xe0, 0xab, 0xbb, 0xe0, 0xab, 0x8d, 0xe0, 0xaa, 0xb8, 0xe0, 0xab, 0xbb}}, comment: "÷ [0.2] GUJARATI LETTER SA (LinkingConsonant) × [9.0] GUJARATI SIGN SHADDA (Extend_ConjunctExtendermConjunctLinker) × [9.0] GUJARATI SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] GUJARATI LETTER SA (LinkingConsonant) × [9.0] GUJARATI SIGN SHADDA (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x80, 0x99, 0xe1, 0x80, 0xb9, 0xe1, 0x80, 0x98, 0xe1, 0x80, 0xac, 0xe1, 0x80, 0xb7}, expected: [][]byte{{0xe1, 0x80, 0x99, 0xe1, 0x80, 0xb9, 0xe1, 0x80, 0x98}, {0xe1, 0x80, 0xac, 0xe1, 0x80, 0xb7}}, comment: "÷ [0.2] MYANMAR LETTER MA (LinkingConsonant) × [9.0] MYANMAR SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] MYANMAR LETTER BHA (LinkingConsonant) ÷ [999.0] MYANMAR VOWEL SIGN AA (XXmLinkingConsonantmExtPict) × [9.0] MYANMAR SIGN DOT BELOW (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x80, 0x84, 0xe1, 0x80, 0xba, 0xe1, 0x80, 0xb9, 0xe1, 0x80, 0x91, 0xe1, 0x80, 0xb9, 0xe1, 0x80, 0x91}, expected: [][]byte{{0xe1, 0x80, 0x84, 0xe1, 0x80, 0xba, 0xe1, 0x80, 0xb9, 0xe1, 0x80, 0x91, 0xe1, 0x80, 0xb9, 0xe1, 0x80, 0x91}}, comment: "÷ [0.2] MYANMAR LETTER NGA (LinkingConsonant) × [9.0] MYANMAR SIGN ASAT (Extend_ConjunctExtendermConjunctLinker) × [9.0] MYANMAR SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] MYANMAR LETTER THA (LinkingConsonant) × [9.0] MYANMAR SIGN VIRAMA (Extend_ConjunctLinker) × [9.3] MYANMAR LETTER THA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0xac, 0x92, 0xe1, 0xac, 0x81, 0xe1, 0xac, 0xb2, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0xaf, 0xe1, 0xac, 0xb2, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0xa2, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0xac, 0xe1, 0xac, 0xb2, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0xa2, 0xe1, 0xac, 0xb8}, expected: [][]byte{{0xe1, 0xac, 0x92, 0xe1, 0xac, 0x81}, {0xe1, 0xac, 0xb2, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0xaf}, {0xe1, 0xac, 0xb2, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0xa2, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0xac}, {0xe1, 0xac, 0xb2, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0xa2, 0xe1, 0xac, 0xb8}}, comment: "÷ [0.2] BALINESE LETTER OKARA TEDUNG (XXmLinkingConsonantmExtPict) × [9.0] BALINESE SIGN ULU CANDRA (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] BALINESE LETTER SA (LinkingConsonant) × [9.0] BALINESE ADEG ADEG (Extend_ConjunctLinker) × [9.3] BALINESE LETTER WA (LinkingConsonant) ÷ [999.0] BALINESE LETTER SA (LinkingConsonant) × [9.0] BALINESE ADEG ADEG (Extend_ConjunctLinker) × [9.3] BALINESE LETTER TA (LinkingConsonant) × [9.0] BALINESE ADEG ADEG (Extend_ConjunctLinker) × [9.3] BALINESE LETTER YA (LinkingConsonant) ÷ [999.0] BALINESE LETTER SA (LinkingConsonant) × [9.0] BALINESE ADEG ADEG (Extend_ConjunctLinker) × [9.3] BALINESE LETTER TA (LinkingConsonant) × [9.0] BALINESE VOWEL SIGN SUKU (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0x9e, 0x9f, 0xe1, 0x9f, 0x92, 0xe1, 0x9e, 0x8f, 0xe1, 0x9f, 0x92, 0xe1, 0x9e, 0x9a, 0xe1, 0x9e, 0xb8}, expected: [][]byte{{0xe1, 0x9e, 0x9f, 0xe1, 0x9f, 0x92, 0xe1, 0x9e, 0x8f, 0xe1, 0x9f, 0x92, 0xe1, 0x9e, 0x9a, 0xe1, 0x9e, 0xb8}}, comment: "÷ [0.2] KHMER LETTER SA (LinkingConsonant) × [9.0] KHMER SIGN COENG (Extend_ConjunctLinker) × [9.3] KHMER LETTER TA (LinkingConsonant) × [9.0] KHMER SIGN COENG (Extend_ConjunctLinker) × [9.3] KHMER LETTER RO (LinkingConsonant) × [9.0] KHMER VOWEL SIGN II (Extend_ConjunctExtendermConjunctLinker) ÷ [0.3]", }, { input: []byte{0xe1, 0xac, 0xa6, 0xe1, 0xac, 0x97, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0x93}, expected: [][]byte{{0xe1, 0xac, 0xa6}, {0xe1, 0xac, 0x97, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0x93}}, comment: "÷ [0.2] BALINESE LETTER NA (LinkingConsonant) ÷ [999.0] BALINESE LETTER NGA (LinkingConsonant) × [9.0] BALINESE ADEG ADEG (Extend_ConjunctLinker) × [9.3] BALINESE LETTER KA (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0xac, 0xa7, 0xe1, 0xac, 0x93, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0x8b, 0xe1, 0xac, 0x8b, 0xe1, 0xac, 0x84}, expected: [][]byte{{0xe1, 0xac, 0xa7}, {0xe1, 0xac, 0x93, 0xe1, 0xad, 0x84, 0xe1, 0xac, 0x8b}, {0xe1, 0xac, 0x8b, 0xe1, 0xac, 0x84}}, comment: "÷ [0.2] BALINESE LETTER PA (LinkingConsonant) ÷ [999.0] BALINESE LETTER KA (LinkingConsonant) × [9.0] BALINESE ADEG ADEG (Extend_ConjunctLinker) × [9.3] BALINESE LETTER RA REPA (LinkingConsonant) ÷ [999.0] BALINESE LETTER RA REPA (LinkingConsonant) × [9.1] BALINESE SIGN BISAH (SpacingMark) ÷ [0.3]", }, { input: []byte{0xe1, 0x9e, 0x95, 0xe1, 0x9f, 0x92, 0xe1, 0x9e, 0xaf, 0xe1, 0x9e, 0x98}, expected: [][]byte{{0xe1, 0x9e, 0x95, 0xe1, 0x9f, 0x92, 0xe1, 0x9e, 0xaf}, {0xe1, 0x9e, 0x98}}, comment: "÷ [0.2] KHMER LETTER PHA (LinkingConsonant) × [9.0] KHMER SIGN COENG (Extend_ConjunctLinker) × [9.3] KHMER INDEPENDENT VOWEL QE (LinkingConsonant) ÷ [999.0] KHMER LETTER MO (LinkingConsonant) ÷ [0.3]", }, { input: []byte{0xe1, 0x9e, 0xa0, 0xe1, 0x9f, 0x92, 0xe1, 0x9e, 0xab, 0xe1, 0x9e, 0x91, 0xe1, 0x9f, 0x90, 0xe1, 0x9e, 0x99}, expected: [][]byte{{0xe1, 0x9e, 0xa0, 0xe1, 0x9f, 0x92, 0xe1, 0x9e, 0xab}, {0xe1, 0x9e, 0x91, 0xe1, 0x9f, 0x90}, {0xe1, 0x9e, 0x99}}, comment: "÷ [0.2] KHMER LETTER HA (LinkingConsonant) × [9.0] KHMER SIGN COENG (Extend_ConjunctLinker) × [9.3] KHMER INDEPENDENT VOWEL RY (LinkingConsonant) ÷ [999.0] KHMER LETTER TO (LinkingConsonant) × [9.0] KHMER SIGN SAMYOK SANNYA (Extend_ConjunctExtendermConjunctLinker) ÷ [999.0] KHMER LETTER YO (LinkingConsonant) ÷ [0.3]", }, } golang-github-clipperhouse-uax29-2.7.0/internal/000077500000000000000000000000001515045622700215405ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/internal/gen/000077500000000000000000000000001515045622700223115ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/internal/gen/go.mod000066400000000000000000000001411515045622700234130ustar00rootroot00000000000000module github.com/clipperhouse/uax29/v2/internal/gen go 1.18 require golang.org/x/text v0.16.0 golang-github-clipperhouse-uax29-2.7.0/internal/gen/go.sum000066400000000000000000000002331515045622700234420ustar00rootroot00000000000000golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= golang-github-clipperhouse-uax29-2.7.0/internal/gen/main.go000066400000000000000000000244031515045622700235670ustar00rootroot00000000000000// Package main generates tries of Unicode properties by calling go generate as the repository root package main import ( "bufio" "bytes" "fmt" "go/format" "io" "net/http" "os" "path/filepath" "sort" "strconv" "strings" "unicode" "unicode/utf8" "github.com/clipperhouse/uax29/v2/internal/gen/triegen" "golang.org/x/text/unicode/rangetable" ) // unicodeVersion is the Unicode version we generate data for. // This is hard-coded rather than using unicode.Version from the Go stdlib, // allowing us to support newer Unicode versions before Go does. const unicodeVersion = "17.0.0" func main() { props := []prop{ // make sure emoji goes first, subsequent props need it { name: "Emoji", url: "https://www.unicode.org/Public/" + unicodeVersion + "/ucd/emoji/emoji-data.txt", }, // InCB (Indic_Conjunct_Break) is needed for GB9c rule in graphemes { name: "InCB", url: "https://www.unicode.org/Public/" + unicodeVersion + "/ucd/DerivedCoreProperties.txt", }, { name: "Word", }, { name: "Phrase", }, { name: "Grapheme", }, { name: "Sentence", }, } for _, p := range props { if err := p.generateTrie(); err != nil { panic(err) } if err := p.generateTests(); err != nil { panic(err) } } } const baseURL = "https://www.unicode.org/Public/" + unicodeVersion + "/ucd/auxiliary" type prop struct { name string url string } func (p prop) URL() string { if p.url != "" { return p.url } if p.name == "Phrase" { p.name = "Word" } return fmt.Sprintf("%s/%sBreakProperty.txt", baseURL, p.name) } func (p prop) TestURL() string { if p.name == "Emoji" { panic("no tests for emoji") } return fmt.Sprintf("%s/%sBreakTest.txt", baseURL, p.name) } func (p prop) PackageName() string { return strings.ToLower(p.name) + "s" } var extendedPictographic []rune // Indic_Conjunct_Break property values for GB9c rule (Unicode 15.1+) var indicConjunctBreak = struct { Consonant []rune Linker []rune Extend []rune }{} func (p prop) generateTrie() error { fmt.Println(p.URL()) resp, err := http.Get(p.URL()) if err != nil { return err } b := bufio.NewReader(resp.Body) runesByProperty := map[string][]rune{} for { s, err := b.ReadString('\n') if err != nil { if err == io.EOF { break } return err } if len(s) == 0 { continue } if s[0] == '\n' || s[0] == '#' { continue } parts := strings.Split(s, ";") runes, err := getRuneRange(parts[0]) if err != nil { return err } var property string if len(parts) >= 3 { // Format: codepoint ; PropertyName ; Value # comment // Used by DerivedCoreProperties.txt for InCB, e.g.: "094D ; InCB; Linker # ..." propName := strings.TrimSpace(parts[1]) split2 := strings.Split(parts[2], "#") propValue := strings.TrimSpace(split2[0]) property = propName + "_" + propValue } else { // Format: codepoint ; PropertyValue # comment split2 := strings.Split(parts[1], "#") property = strings.TrimSpace(split2[0]) } runesByProperty[property] = append(runesByProperty[property], runes...) } // Words and graphemes need Extended_Pictographic property const key = "Extended_Pictographic" if p.name == "Emoji" { extendedPictographic = runesByProperty[key] // We don't need to generate emoji package return nil } // InCB (Indic_Conjunct_Break) is needed for GB9c rule if p.name == "InCB" { indicConjunctBreak.Consonant = runesByProperty["InCB_Consonant"] indicConjunctBreak.Linker = runesByProperty["InCB_Linker"] indicConjunctBreak.Extend = runesByProperty["InCB_Extend"] // We don't need to generate InCB package return nil } if p.name == "Word" || p.name == "Phrase" || p.name == "Grapheme" { if len(extendedPictographic) == 0 { panic("didn't get emoji data; make sure it's loaded first") } runesByProperty[key] = extendedPictographic } // Graphemes need InCB properties for GB9c rule if p.name == "Grapheme" { if len(indicConjunctBreak.Consonant) == 0 { panic("didn't get InCB data; make sure it's loaded first") } runesByProperty["InCB_Consonant"] = indicConjunctBreak.Consonant runesByProperty["InCB_Linker"] = indicConjunctBreak.Linker runesByProperty["InCB_Extend"] = indicConjunctBreak.Extend } if p.name == "Word" { // Concatenate UAX 29 definition of Katakana with Han and Hiragana // The rangetable unicode.Katakana isn't complete for // our purposes, see https://www.unicode.org/reports/tr29/tr29-47.html#Katakana table := rangetable.Merge(unicode.Han, unicode.Hiragana) var ideo []rune rangetable.Visit(table, func(r rune) { ideo = append(ideo, r) }) runesByProperty["BleveIdeographic"] = append(runesByProperty["Katakana"], ideo...) } // Keep the order stable properties := make([]string, 0, len(runesByProperty)) for property := range runesByProperty { properties = append(properties, property) } sort.Strings(properties) iotasByProperty := map[string]uint64{} for i, property := range properties { iotasByProperty[property] = 1 << i } iotasByRune := map[rune]uint64{} for property, runes := range runesByProperty { for _, r := range runes { iotasByRune[r] = iotasByRune[r] | iotasByProperty[property] } } trie := triegen.NewTrie(p.PackageName()) for r, iotas := range iotasByRune { trie.Insert(r, iotas) } err = writeTrie(p, trie, iotasByProperty) if err != nil { return err } return nil } type unicodeTest struct { input []byte expected [][]byte comment string } func (p prop) generateTests() error { if p.name == "Emoji" { return nil } if p.name == "InCB" { return nil } if p.name == "Phrase" { return nil } fmt.Println(p.TestURL()) resp, err := http.Get(p.TestURL()) if err != nil { return err } sc := bufio.NewScanner(resp.Body) // defaults to ScanLines var unicodeTests []unicodeTest for sc.Scan() { line := sc.Text() if line[0] == '#' { // comment line, ignore continue } test := unicodeTest{} parts := strings.Split(line, "#") test.comment = strings.TrimSpace(parts[1]) data := parts[0] segments := strings.Split(data, "÷") for _, segment := range segments { if len(segment) < 4 { continue } vals := strings.Split(segment, " ") var expected []byte for _, val := range vals { if len(val) < 4 { continue } hex := "0x" + val r64, err := strconv.ParseInt(hex, 0, 32) if err != nil { return err } r := rune(r64) rb := make([]byte, utf8.RuneLen(r)) utf8.EncodeRune(rb, r) test.input = append(test.input, rb...) expected = append(expected, rb...) } test.expected = append(test.expected, expected) } unicodeTests = append(unicodeTests, test) } if err := sc.Err(); err != nil { return err } return p.writeTests(unicodeTests) } func getRuneRange(s string) ([]rune, error) { s = strings.TrimSpace(s) hilo := strings.Split(s, "..") lo64, err := strconv.ParseInt("0x"+hilo[0], 0, 32) if err != nil { return nil, err } lo := rune(lo64) runes := []rune{lo} if len(hilo) == 1 { return runes, nil } hi64, err := strconv.ParseInt("0x"+hilo[1], 0, 32) if err != nil { return nil, err } hi := rune(hi64) if hi == lo { return runes, nil } // Skip first, inclusive of last for r := lo + 1; r <= hi; r++ { runes = append(runes, r) } return runes, nil } func (p prop) writeTests(tests []unicodeTest) error { buf := bytes.Buffer{} fmt.Fprintf(&buf, `package %s_test // generated by github.com/clipperhouse/uax29/v2 // from %s `, p.PackageName(), p.TestURL()) fmt.Fprintf(&buf, ` type unicodeTest struct { input []byte expected [][]byte comment string } var unicodeTests = [%d]unicodeTest { `, len(tests)) for _, t := range tests { fmt.Fprintf(&buf, `{ input: %#v, expected: %#v, comment: %#v, }, `, t.input, t.expected, t.comment) } fmt.Fprintf(&buf, "}\n\n") byts := buf.Bytes() byts = bytes.ReplaceAll(byts, []byte("[]uint8{0x"), []byte("{0x")) byts = bytes.ReplaceAll(byts, []byte("[]uint8{"), []byte("[]byte{")) formatted, err := format.Source(byts) if err != nil { return err } f := filepath.Join("../../", p.PackageName(), "unicode_test.go") dst, err := os.Create(f) if err != nil { return err } defer dst.Close() _, err = dst.Write(formatted) if err != nil { return err } return nil } func writeTrie(prop prop, trie *triegen.Trie, iotasByProperty map[string]uint64) error { buf := bytes.Buffer{} fmt.Fprintln(&buf, "package "+prop.PackageName()) fmt.Fprintln(&buf, "\n// generated by github.com/clipperhouse/uax29/v2\n// from "+prop.URL()) fmt.Fprintln(&buf) // Keep the order stable properties := make([]string, 0, len(iotasByProperty)) for property := range iotasByProperty { properties = append(properties, property) } sort.Strings(properties) inttype := "" len := len(properties) switch { case len < 8: inttype = "uint8" case len < 16: inttype = "uint16" case len < 32: inttype = "uint32" default: inttype = "uint64" } fmt.Fprintf(&buf, "type property %s\n\n", inttype) fmt.Fprintln(&buf, "const (") for i, property := range properties { name := strings.ReplaceAll(property, "_", "") if i == 0 { fmt.Fprintf(&buf, "_%s property = 1 << iota\n", name) continue } fmt.Fprintf(&buf, "_%s\n", name) } fmt.Fprintln(&buf, ")") _, err := triegen.Gen(&buf, prop.PackageName(), []*triegen.Trie{trie}) if err != nil { return err } // We have generic tries now b := buf.Bytes() typename := prop.PackageName() + "Trie" typeDefSig := `type ` + typename + ` struct` noTypeDef := `// ` + typeDefSig b = bytes.ReplaceAll(b, []byte(typeDefSig), []byte(noTypeDef)) lookupSig := `(t *` + typename + `) lookup(s []byte)` genericLookupSig := `lookup[T ~string | ~[]byte](s T)` b = bytes.ReplaceAll(b, []byte(lookupSig), []byte(genericLookupSig)) lookupValueSig := `(t *` + typename + `) lookupValue` genericLookupValueSig := `lookupValue` b = bytes.ReplaceAll(b, []byte(lookupValueSig), []byte(genericLookupValueSig)) lookupCallSig := `t.lookupValue(` genericLookupCallSig := `lookupValue(` b = bytes.ReplaceAll(b, []byte(lookupCallSig), []byte(genericLookupCallSig)) formatted, err := format.Source(b) if err != nil { return err } f := filepath.Join("../../", prop.PackageName(), "trie.go") dst, err := os.Create(f) if err != nil { return err } defer dst.Close() _, err = dst.Write(formatted) if err != nil { return err } return nil } golang-github-clipperhouse-uax29-2.7.0/internal/gen/triegen/000077500000000000000000000000001515045622700237465ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/internal/gen/triegen/LICENSE000066400000000000000000000026551515045622700247630ustar00rootroot00000000000000Copyright 2009 The Go Authors. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Google LLC nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. golang-github-clipperhouse-uax29-2.7.0/internal/gen/triegen/compact.go000066400000000000000000000037661515045622700257370ustar00rootroot00000000000000// Copyright 2014 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 triegen // This file defines Compacter and its implementations. import "io" // A Compacter generates an alternative, more space-efficient way to store a // trie value block. A trie value block holds all possible values for the last // byte of a UTF-8 encoded rune. Excluding ASCII characters, a trie value block // always has 64 values, as a UTF-8 encoding ends with a byte in [0x80, 0xC0). type Compacter interface { // Size returns whether the Compacter could encode the given block as well // as its size in case it can. len(v) is always 64. Size(v []uint64) (sz int, ok bool) // Store stores the block using the Compacter's compression method. // It returns a handle with which the block can be retrieved. // len(v) is always 64. Store(v []uint64) uint32 // Print writes the data structures associated to the given store to w. Print(w io.Writer) error // Handler returns the name of a function that gets called during trie // lookup for blocks generated by the Compacter. The function should be of // the form func (n uint32, b byte) uint64, where n is the index returned by // the Compacter's Store method and b is the last byte of the UTF-8 // encoding, where 0x80 <= b < 0xC0, for which to do the lookup in the // block. Handler() string } // simpleCompacter is the default Compacter used by builder. It implements a // normal trie block. type simpleCompacter builder func (b *simpleCompacter) Size([]uint64) (sz int, ok bool) { return blockSize * b.ValueSize, true } func (b *simpleCompacter) Store(v []uint64) uint32 { h := uint32(len(b.ValueBlocks) - blockOffset) b.ValueBlocks = append(b.ValueBlocks, v) return h } func (b *simpleCompacter) Print(io.Writer) error { // Structures are printed in print.go. return nil } func (b *simpleCompacter) Handler() string { panic("Handler should be special-cased for this Compacter") } golang-github-clipperhouse-uax29-2.7.0/internal/gen/triegen/data_test.go000066400000000000000000000543011515045622700262500ustar00rootroot00000000000000// This file is generated with "go test -tags generate". DO NOT EDIT! // +build !generate package triegen_test // 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 *randTrie) lookup(s []byte) (v uint8, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return randValues[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := randIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := randIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = randIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := randIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = randIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = randIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // lookupUnsafe returns the trie value for the first UTF-8 encoding in s. // s must start with a full and valid UTF-8 encoded rune. func (t *randTrie) lookupUnsafe(s []byte) uint8 { c0 := s[0] if c0 < 0x80 { // is ASCII return randValues[c0] } i := randIndex[c0] if c0 < 0xE0 { // 2-byte UTF-8 return t.lookupValue(uint32(i), s[1]) } i = randIndex[uint32(i)<<6+uint32(s[1])] if c0 < 0xF0 { // 3-byte UTF-8 return t.lookupValue(uint32(i), s[2]) } i = randIndex[uint32(i)<<6+uint32(s[2])] if c0 < 0xF8 { // 4-byte UTF-8 return t.lookupValue(uint32(i), s[3]) } return 0 } // 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 *randTrie) lookupString(s string) (v uint8, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return randValues[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := randIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := randIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = randIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := randIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = randIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = randIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s. // s must start with a full and valid UTF-8 encoded rune. func (t *randTrie) lookupStringUnsafe(s string) uint8 { c0 := s[0] if c0 < 0x80 { // is ASCII return randValues[c0] } i := randIndex[c0] if c0 < 0xE0 { // 2-byte UTF-8 return t.lookupValue(uint32(i), s[1]) } i = randIndex[uint32(i)<<6+uint32(s[1])] if c0 < 0xF0 { // 3-byte UTF-8 return t.lookupValue(uint32(i), s[2]) } i = randIndex[uint32(i)<<6+uint32(s[2])] if c0 < 0xF8 { // 4-byte UTF-8 return t.lookupValue(uint32(i), s[3]) } return 0 } // randTrie. Total size: 9280 bytes (9.06 KiB). Checksum: 6debd324a8debb8f. type randTrie struct{} func newRandTrie(i int) *randTrie { return &randTrie{} } // lookupValue determines the type of block n and looks up the value for b. func (t *randTrie) lookupValue(n uint32, b byte) uint8 { switch { default: return uint8(randValues[n<<6+uint32(b)]) } } // randValues: 56 blocks, 3584 entries, 3584 bytes // The third block is the zero block. var randValues = [3584]uint8{ // Block 0x0, offset 0x0 // Block 0x1, offset 0x40 // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc9: 0x0001, // Block 0x4, offset 0x100 0x100: 0x0001, // Block 0x5, offset 0x140 0x155: 0x0001, // Block 0x6, offset 0x180 0x196: 0x0001, // Block 0x7, offset 0x1c0 0x1ef: 0x0001, // Block 0x8, offset 0x200 0x206: 0x0001, // Block 0x9, offset 0x240 0x258: 0x0001, // Block 0xa, offset 0x280 0x288: 0x0001, // Block 0xb, offset 0x2c0 0x2f2: 0x0001, // Block 0xc, offset 0x300 0x304: 0x0001, // Block 0xd, offset 0x340 0x34b: 0x0001, // Block 0xe, offset 0x380 0x3ba: 0x0001, // Block 0xf, offset 0x3c0 0x3f5: 0x0001, // Block 0x10, offset 0x400 0x41d: 0x0001, // Block 0x11, offset 0x440 0x442: 0x0001, // Block 0x12, offset 0x480 0x4bb: 0x0001, // Block 0x13, offset 0x4c0 0x4e9: 0x0001, // Block 0x14, offset 0x500 0x53e: 0x0001, // Block 0x15, offset 0x540 0x55f: 0x0001, // Block 0x16, offset 0x580 0x5b7: 0x0001, // Block 0x17, offset 0x5c0 0x5d9: 0x0001, // Block 0x18, offset 0x600 0x60e: 0x0001, // Block 0x19, offset 0x640 0x652: 0x0001, // Block 0x1a, offset 0x680 0x68f: 0x0001, // Block 0x1b, offset 0x6c0 0x6dc: 0x0001, // Block 0x1c, offset 0x700 0x703: 0x0001, // Block 0x1d, offset 0x740 0x741: 0x0001, // Block 0x1e, offset 0x780 0x79b: 0x0001, // Block 0x1f, offset 0x7c0 0x7f1: 0x0001, // Block 0x20, offset 0x800 0x833: 0x0001, // Block 0x21, offset 0x840 0x853: 0x0001, // Block 0x22, offset 0x880 0x8a2: 0x0001, // Block 0x23, offset 0x8c0 0x8f8: 0x0001, // Block 0x24, offset 0x900 0x917: 0x0001, // Block 0x25, offset 0x940 0x945: 0x0001, // Block 0x26, offset 0x980 0x99e: 0x0001, // Block 0x27, offset 0x9c0 0x9fd: 0x0001, // Block 0x28, offset 0xa00 0xa0d: 0x0001, // Block 0x29, offset 0xa40 0xa66: 0x0001, // Block 0x2a, offset 0xa80 0xaab: 0x0001, // Block 0x2b, offset 0xac0 0xaea: 0x0001, // Block 0x2c, offset 0xb00 0xb2d: 0x0001, // Block 0x2d, offset 0xb40 0xb54: 0x0001, // Block 0x2e, offset 0xb80 0xb90: 0x0001, // Block 0x2f, offset 0xbc0 0xbe5: 0x0001, // Block 0x30, offset 0xc00 0xc28: 0x0001, // Block 0x31, offset 0xc40 0xc7c: 0x0001, // Block 0x32, offset 0xc80 0xcbf: 0x0001, // Block 0x33, offset 0xcc0 0xcc7: 0x0001, // Block 0x34, offset 0xd00 0xd34: 0x0001, // Block 0x35, offset 0xd40 0xd61: 0x0001, // Block 0x36, offset 0xd80 0xdb9: 0x0001, // Block 0x37, offset 0xdc0 0xdda: 0x0001, } // randIndex: 89 blocks, 5696 entries, 5696 bytes // Block 0 is the zero block. var randIndex = [5696]uint8{ // Block 0x0, offset 0x0 // Block 0x1, offset 0x40 // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xe1: 0x02, 0xe3: 0x03, 0xe4: 0x04, 0xea: 0x05, 0xeb: 0x06, 0xec: 0x07, 0xf0: 0x10, 0xf1: 0x24, 0xf2: 0x3d, 0xf3: 0x4f, 0xf4: 0x56, // Block 0x4, offset 0x100 0x107: 0x01, // Block 0x5, offset 0x140 0x16c: 0x02, // Block 0x6, offset 0x180 0x19c: 0x03, 0x1ae: 0x04, // Block 0x7, offset 0x1c0 0x1d8: 0x05, 0x1f7: 0x06, // Block 0x8, offset 0x200 0x20c: 0x07, // Block 0x9, offset 0x240 0x24a: 0x08, // Block 0xa, offset 0x280 0x2b6: 0x09, // Block 0xb, offset 0x2c0 0x2d5: 0x0a, // Block 0xc, offset 0x300 0x31a: 0x0b, // Block 0xd, offset 0x340 0x373: 0x0c, // Block 0xe, offset 0x380 0x38b: 0x0d, // Block 0xf, offset 0x3c0 0x3f0: 0x0e, // Block 0x10, offset 0x400 0x433: 0x0f, // Block 0x11, offset 0x440 0x45d: 0x10, // Block 0x12, offset 0x480 0x491: 0x08, 0x494: 0x09, 0x497: 0x0a, 0x49b: 0x0b, 0x49c: 0x0c, 0x4a1: 0x0d, 0x4ad: 0x0e, 0x4ba: 0x0f, // Block 0x13, offset 0x4c0 0x4c1: 0x11, // Block 0x14, offset 0x500 0x531: 0x12, // Block 0x15, offset 0x540 0x546: 0x13, // Block 0x16, offset 0x580 0x5ab: 0x14, // Block 0x17, offset 0x5c0 0x5d4: 0x11, 0x5fe: 0x11, // Block 0x18, offset 0x600 0x618: 0x0a, // Block 0x19, offset 0x640 0x65b: 0x15, // Block 0x1a, offset 0x680 0x6a0: 0x16, // Block 0x1b, offset 0x6c0 0x6d2: 0x17, 0x6f6: 0x18, // Block 0x1c, offset 0x700 0x711: 0x19, // Block 0x1d, offset 0x740 0x768: 0x1a, // Block 0x1e, offset 0x780 0x783: 0x1b, // Block 0x1f, offset 0x7c0 0x7f9: 0x1c, // Block 0x20, offset 0x800 0x831: 0x1d, // Block 0x21, offset 0x840 0x85e: 0x1e, // Block 0x22, offset 0x880 0x898: 0x1f, // Block 0x23, offset 0x8c0 0x8c7: 0x18, 0x8d5: 0x14, 0x8f7: 0x20, 0x8fe: 0x1f, // Block 0x24, offset 0x900 0x905: 0x21, // Block 0x25, offset 0x940 0x966: 0x03, // Block 0x26, offset 0x980 0x981: 0x07, 0x983: 0x11, 0x989: 0x12, 0x98a: 0x13, 0x98e: 0x14, 0x98f: 0x15, 0x992: 0x16, 0x995: 0x17, 0x996: 0x18, 0x998: 0x19, 0x999: 0x1a, 0x99b: 0x1b, 0x99f: 0x1c, 0x9a3: 0x1d, 0x9ad: 0x1e, 0x9af: 0x1f, 0x9b0: 0x20, 0x9b1: 0x21, 0x9b8: 0x22, 0x9bd: 0x23, // Block 0x27, offset 0x9c0 0x9cd: 0x22, // Block 0x28, offset 0xa00 0xa0c: 0x08, // Block 0x29, offset 0xa40 0xa6f: 0x1c, // Block 0x2a, offset 0xa80 0xa90: 0x1a, 0xaaf: 0x23, // Block 0x2b, offset 0xac0 0xae3: 0x19, 0xae8: 0x24, 0xafc: 0x25, // Block 0x2c, offset 0xb00 0xb13: 0x26, // Block 0x2d, offset 0xb40 0xb67: 0x1c, // Block 0x2e, offset 0xb80 0xb8f: 0x0b, // Block 0x2f, offset 0xbc0 0xbcb: 0x27, 0xbe7: 0x26, // Block 0x30, offset 0xc00 0xc34: 0x16, // Block 0x31, offset 0xc40 0xc62: 0x03, // Block 0x32, offset 0xc80 0xcbb: 0x12, // Block 0x33, offset 0xcc0 0xcdf: 0x09, // Block 0x34, offset 0xd00 0xd34: 0x0a, // Block 0x35, offset 0xd40 0xd41: 0x1e, // Block 0x36, offset 0xd80 0xd83: 0x28, // Block 0x37, offset 0xdc0 0xdc0: 0x15, // Block 0x38, offset 0xe00 0xe1a: 0x15, // Block 0x39, offset 0xe40 0xe65: 0x29, // Block 0x3a, offset 0xe80 0xe86: 0x1f, // Block 0x3b, offset 0xec0 0xeec: 0x18, // Block 0x3c, offset 0xf00 0xf28: 0x2a, // Block 0x3d, offset 0xf40 0xf53: 0x08, // Block 0x3e, offset 0xf80 0xfa2: 0x2b, 0xfaa: 0x17, // Block 0x3f, offset 0xfc0 0xfc0: 0x25, 0xfc2: 0x26, 0xfc9: 0x27, 0xfcd: 0x28, 0xfce: 0x29, 0xfd5: 0x2a, 0xfd8: 0x2b, 0xfd9: 0x2c, 0xfdf: 0x2d, 0xfe1: 0x2e, 0xfe2: 0x2f, 0xfe3: 0x30, 0xfe6: 0x31, 0xfe9: 0x32, 0xfec: 0x33, 0xfed: 0x34, 0xfef: 0x35, 0xff1: 0x36, 0xff2: 0x37, 0xff3: 0x38, 0xff4: 0x39, 0xffa: 0x3a, 0xffc: 0x3b, 0xffe: 0x3c, // Block 0x40, offset 0x1000 0x102c: 0x2c, // Block 0x41, offset 0x1040 0x1074: 0x2c, // Block 0x42, offset 0x1080 0x108c: 0x08, 0x10a0: 0x2d, // Block 0x43, offset 0x10c0 0x10e8: 0x10, // Block 0x44, offset 0x1100 0x110f: 0x13, // Block 0x45, offset 0x1140 0x114b: 0x2e, // Block 0x46, offset 0x1180 0x118b: 0x23, 0x119d: 0x0c, // Block 0x47, offset 0x11c0 0x11c3: 0x12, 0x11f9: 0x0f, // Block 0x48, offset 0x1200 0x121e: 0x1b, // Block 0x49, offset 0x1240 0x1270: 0x2f, // Block 0x4a, offset 0x1280 0x128a: 0x1b, 0x12a7: 0x02, // Block 0x4b, offset 0x12c0 0x12fb: 0x14, // Block 0x4c, offset 0x1300 0x1333: 0x30, // Block 0x4d, offset 0x1340 0x134d: 0x31, // Block 0x4e, offset 0x1380 0x138e: 0x15, // Block 0x4f, offset 0x13c0 0x13f4: 0x32, // Block 0x50, offset 0x1400 0x141b: 0x33, // Block 0x51, offset 0x1440 0x1448: 0x3e, 0x1449: 0x3f, 0x144a: 0x40, 0x144f: 0x41, 0x1459: 0x42, 0x145c: 0x43, 0x145e: 0x44, 0x145f: 0x45, 0x1468: 0x46, 0x1469: 0x47, 0x146c: 0x48, 0x146d: 0x49, 0x146e: 0x4a, 0x1472: 0x4b, 0x1473: 0x4c, 0x1479: 0x4d, 0x147b: 0x4e, // Block 0x52, offset 0x1480 0x1480: 0x34, 0x1499: 0x11, 0x14b6: 0x2c, // Block 0x53, offset 0x14c0 0x14e4: 0x0d, // Block 0x54, offset 0x1500 0x1527: 0x08, // Block 0x55, offset 0x1540 0x1555: 0x2b, // Block 0x56, offset 0x1580 0x15b2: 0x35, // Block 0x57, offset 0x15c0 0x15f2: 0x1c, 0x15f4: 0x29, // Block 0x58, offset 0x1600 0x1600: 0x50, 0x1603: 0x51, 0x1608: 0x52, 0x160a: 0x53, 0x160d: 0x54, 0x160e: 0x55, } // 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 *multiTrie) lookup(s []byte) (v uint64, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return t.ascii[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := t.utf8Start[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := t.utf8Start[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = multiIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := t.utf8Start[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = multiIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = multiIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // lookupUnsafe returns the trie value for the first UTF-8 encoding in s. // s must start with a full and valid UTF-8 encoded rune. func (t *multiTrie) lookupUnsafe(s []byte) uint64 { c0 := s[0] if c0 < 0x80 { // is ASCII return t.ascii[c0] } i := t.utf8Start[c0] if c0 < 0xE0 { // 2-byte UTF-8 return t.lookupValue(uint32(i), s[1]) } i = multiIndex[uint32(i)<<6+uint32(s[1])] if c0 < 0xF0 { // 3-byte UTF-8 return t.lookupValue(uint32(i), s[2]) } i = multiIndex[uint32(i)<<6+uint32(s[2])] if c0 < 0xF8 { // 4-byte UTF-8 return t.lookupValue(uint32(i), s[3]) } return 0 } // 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 *multiTrie) lookupString(s string) (v uint64, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return t.ascii[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := t.utf8Start[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := t.utf8Start[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = multiIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := t.utf8Start[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = multiIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = multiIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s. // s must start with a full and valid UTF-8 encoded rune. func (t *multiTrie) lookupStringUnsafe(s string) uint64 { c0 := s[0] if c0 < 0x80 { // is ASCII return t.ascii[c0] } i := t.utf8Start[c0] if c0 < 0xE0 { // 2-byte UTF-8 return t.lookupValue(uint32(i), s[1]) } i = multiIndex[uint32(i)<<6+uint32(s[1])] if c0 < 0xF0 { // 3-byte UTF-8 return t.lookupValue(uint32(i), s[2]) } i = multiIndex[uint32(i)<<6+uint32(s[2])] if c0 < 0xF8 { // 4-byte UTF-8 return t.lookupValue(uint32(i), s[3]) } return 0 } // multiTrie. Total size: 18250 bytes (17.82 KiB). Checksum: a69a609d8696aa5e. type multiTrie struct { ascii []uint64 // index for ASCII bytes utf8Start []uint8 // index for UTF-8 bytes >= 0xC0 } func newMultiTrie(i int) *multiTrie { h := multiTrieHandles[i] return &multiTrie{multiValues[uint32(h.ascii)<<6:], multiIndex[uint32(h.multi)<<6:]} } type multiTrieHandle struct { ascii, multi uint8 } // multiTrieHandles: 5 handles, 10 bytes var multiTrieHandles = [5]multiTrieHandle{ {0, 0}, // 8c1e77823143d35c: all {0, 23}, // 8fb58ff8243b45b0: ASCII only {0, 23}, // 8fb58ff8243b45b0: ASCII only 2 {0, 24}, // 2ccc43994f11046f: BMP only {30, 25}, // ce448591bdcb4733: No BMP } // lookupValue determines the type of block n and looks up the value for b. func (t *multiTrie) lookupValue(n uint32, b byte) uint64 { switch { default: return uint64(multiValues[n<<6+uint32(b)]) } } // multiValues: 32 blocks, 2048 entries, 16384 bytes // The third block is the zero block. var multiValues = [2048]uint64{ // Block 0x0, offset 0x0 0x03: 0x6e361699800b9fb8, 0x04: 0x52d3935a34f6f0b, 0x05: 0x2948319393e7ef10, 0x07: 0x20f03b006704f663, 0x08: 0x6c15c0732bb2495f, 0x09: 0xe54e2c59d953551, 0x0f: 0x33d8a825807d8037, 0x10: 0x6ecd93cb12168b92, 0x11: 0x6a81c9c0ce86e884, 0x1f: 0xa03e77aac8be79b, 0x20: 0x28591d0e7e486efa, 0x21: 0x716fa3bc398dec8, 0x3f: 0x4fd3bcfa72bce8b0, // Block 0x1, offset 0x40 0x40: 0x3cbaef3db8ba5f12, 0x41: 0x2d262347c1f56357, 0x7f: 0x782caa2d25a418a9, // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc0: 0x6bbd1f937b1ff5d2, 0xc1: 0x732e23088d2eb8a4, // Block 0x4, offset 0x100 0x13f: 0x56f8c4c82f5962dc, // Block 0x5, offset 0x140 0x140: 0x57dc4544729a5da2, 0x141: 0x2f62f9cd307ffa0d, // Block 0x6, offset 0x180 0x1bf: 0x7bf4d0ebf302a088, // Block 0x7, offset 0x1c0 0x1c0: 0x1f0d67f249e59931, 0x1c1: 0x3011def73aa550c7, // Block 0x8, offset 0x200 0x23f: 0x5de81c1dff6bf29d, // Block 0x9, offset 0x240 0x240: 0x752c035737b825e8, 0x241: 0x1e793399081e3bb3, // Block 0xa, offset 0x280 0x2bf: 0x6a28f01979cbf059, // Block 0xb, offset 0x2c0 0x2c0: 0x373a4b0f2cbd4c74, 0x2c1: 0x4fd2c288683b767c, // Block 0xc, offset 0x300 0x33f: 0x5a10ffa9e29184fb, // Block 0xd, offset 0x340 0x340: 0x700f9bdb53fff6a5, 0x341: 0xcde93df0427eb79, // Block 0xe, offset 0x380 0x3bf: 0x74071288fff39c76, // Block 0xf, offset 0x3c0 0x3c0: 0x481fc2f510e5268a, 0x3c1: 0x7565c28164204849, // Block 0x10, offset 0x400 0x43f: 0x5676a62fd49c6bec, // Block 0x11, offset 0x440 0x440: 0x2f2d15776cbafc6b, 0x441: 0x4c55e8dc0ff11a3f, // Block 0x12, offset 0x480 0x4bf: 0x69d6f0fe711fafc9, // Block 0x13, offset 0x4c0 0x4c0: 0x33181de28cfb062d, 0x4c1: 0x2ef3adc6bb2f2d02, // Block 0x14, offset 0x500 0x53f: 0xe03b31814c95f8b, // Block 0x15, offset 0x540 0x540: 0x3bf6dc9a1c115603, 0x541: 0x6984ec9b7f51f7fc, // Block 0x16, offset 0x580 0x5bf: 0x3c02ea92fb168559, // Block 0x17, offset 0x5c0 0x5c0: 0x1badfe42e7629494, 0x5c1: 0x6dc4a554005f7645, // Block 0x18, offset 0x600 0x63f: 0x3bb2ed2a72748f4b, // Block 0x19, offset 0x640 0x640: 0x291354cd6767ec10, 0x641: 0x2c3a4715e3c070d6, // Block 0x1a, offset 0x680 0x6bf: 0x352711cfb7236418, // Block 0x1b, offset 0x6c0 0x6c0: 0x3a59d34fb8bceda, 0x6c1: 0x5e90d8ebedd64fa1, // Block 0x1c, offset 0x700 0x73f: 0x7191a77b28d23110, // Block 0x1d, offset 0x740 0x740: 0x4ca7f0c1623423d8, 0x741: 0x4f7156d996e2d0de, // Block 0x1e, offset 0x780 // Block 0x1f, offset 0x7c0 } // multiIndex: 29 blocks, 1856 entries, 1856 bytes // Block 0 is the zero block. var multiIndex = [1856]uint8{ // Block 0x0, offset 0x0 // Block 0x1, offset 0x40 // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc2: 0x01, 0xc3: 0x02, 0xc4: 0x03, 0xc7: 0x04, 0xc8: 0x05, 0xcf: 0x06, 0xd0: 0x07, 0xdf: 0x08, 0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xe4: 0x06, 0xe7: 0x07, 0xe8: 0x08, 0xef: 0x09, 0xf0: 0x0e, 0xf1: 0x11, 0xf2: 0x13, 0xf3: 0x15, 0xf4: 0x17, // Block 0x4, offset 0x100 0x120: 0x09, 0x13f: 0x0a, // Block 0x5, offset 0x140 0x140: 0x0b, 0x17f: 0x0c, // Block 0x6, offset 0x180 0x180: 0x0d, // Block 0x7, offset 0x1c0 0x1ff: 0x0e, // Block 0x8, offset 0x200 0x200: 0x0f, // Block 0x9, offset 0x240 0x27f: 0x10, // Block 0xa, offset 0x280 0x280: 0x11, // Block 0xb, offset 0x2c0 0x2ff: 0x12, // Block 0xc, offset 0x300 0x300: 0x13, // Block 0xd, offset 0x340 0x37f: 0x14, // Block 0xe, offset 0x380 0x380: 0x15, // Block 0xf, offset 0x3c0 0x3ff: 0x16, // Block 0x10, offset 0x400 0x410: 0x0a, 0x41f: 0x0b, 0x420: 0x0c, 0x43f: 0x0d, // Block 0x11, offset 0x440 0x440: 0x17, // Block 0x12, offset 0x480 0x4bf: 0x18, // Block 0x13, offset 0x4c0 0x4c0: 0x0f, 0x4ff: 0x10, // Block 0x14, offset 0x500 0x500: 0x19, // Block 0x15, offset 0x540 0x540: 0x12, // Block 0x16, offset 0x580 0x5bf: 0x1a, // Block 0x17, offset 0x5c0 0x5ff: 0x14, // Block 0x18, offset 0x600 0x600: 0x1b, // Block 0x19, offset 0x640 0x640: 0x16, // Block 0x1a, offset 0x680 // Block 0x1b, offset 0x6c0 0x6c2: 0x01, 0x6c3: 0x02, 0x6c4: 0x03, 0x6c7: 0x04, 0x6c8: 0x05, 0x6cf: 0x06, 0x6d0: 0x07, 0x6df: 0x08, 0x6e0: 0x02, 0x6e1: 0x03, 0x6e2: 0x04, 0x6e3: 0x05, 0x6e4: 0x06, 0x6e7: 0x07, 0x6e8: 0x08, 0x6ef: 0x09, // Block 0x1c, offset 0x700 0x730: 0x0e, 0x731: 0x11, 0x732: 0x13, 0x733: 0x15, 0x734: 0x17, } golang-github-clipperhouse-uax29-2.7.0/internal/gen/triegen/gen_test.go000066400000000000000000000032141515045622700261050ustar00rootroot00000000000000// Copyright 2014 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 generate package triegen_test // The code in this file generates captures and writes the tries generated in // the examples to data_test.go. To invoke it, run: // go test -tags=generate // // Making the generation code a "test" allows us to link in the necessary test // code. import ( "log" "os" "os/exec" ) func init() { const tmpfile = "tmpout" const dstfile = "data_test.go" f, err := os.Create(tmpfile) if err != nil { log.Fatalf("Could not create output file: %v", err) } defer os.Remove(tmpfile) defer f.Close() // We exit before this function returns, regardless of success or failure, // so there's no need to save (and later restore) the existing genWriter // value. genWriter = f f.Write([]byte(header)) Example_build() ExampleGen_build() if err := exec.Command("gofmt", "-w", tmpfile).Run(); err != nil { log.Fatal(err) } os.Remove(dstfile) os.Rename(tmpfile, dstfile) os.Exit(0) } const header = `// This file is generated with "go test -tags generate". DO NOT EDIT! // +build !generate package triegen_test ` // Stubs for generated tries. These are needed as we exclude data_test.go if // the generate flag is set. This will clearly make the tests fail, but that // is okay. It allows us to bootstrap. type trie struct{} func (t *trie) lookupString(string) (uint8, int) { return 0, 1 } func (t *trie) lookupStringUnsafe(string) uint64 { return 0 } func newRandTrie(i int) *trie { return &trie{} } func newMultiTrie(i int) *trie { return &trie{} } golang-github-clipperhouse-uax29-2.7.0/internal/gen/triegen/print.go000066400000000000000000000150671515045622700254420ustar00rootroot00000000000000// Copyright 2014 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 triegen import ( "bytes" "fmt" "io" "strings" "text/template" ) // print writes all the data structures as well as the code necessary to use the // trie to w. func (b *builder) print(w io.Writer) error { b.Stats.NValueEntries = len(b.ValueBlocks) * blockSize b.Stats.NValueBytes = len(b.ValueBlocks) * blockSize * b.ValueSize b.Stats.NIndexEntries = len(b.IndexBlocks) * blockSize b.Stats.NIndexBytes = len(b.IndexBlocks) * blockSize * b.IndexSize b.Stats.NHandleBytes = len(b.Trie) * 2 * b.IndexSize // If we only have one root trie, all starter blocks are at position 0 and // we can access the arrays directly. if len(b.Trie) == 1 { // At this point we cannot refer to the generated tables directly. b.ASCIIBlock = b.Name + "Values" b.StarterBlock = b.Name + "Index" } else { // Otherwise we need to have explicit starter indexes in the trie // structure. b.ASCIIBlock = "t.ascii" b.StarterBlock = "t.utf8Start" } b.SourceType = "[]byte" if err := lookupGen.Execute(w, b); err != nil { return err } if err := trieGen.Execute(w, b); err != nil { return err } for _, c := range b.Compactions { if err := c.c.Print(w); err != nil { return err } } return nil } func printValues(n int, values []uint64) string { w := &bytes.Buffer{} boff := n * blockSize fmt.Fprintf(w, "\t// Block %#x, offset %#x", n, boff) var newline bool for i, v := range values { if i%6 == 0 { newline = true } if v != 0 { if newline { fmt.Fprintf(w, "\n") newline = false } fmt.Fprintf(w, "\t%#02x:%#04x, ", boff+i, v) } } return w.String() } func printIndex(b *builder, nr int, n *node) string { w := &bytes.Buffer{} boff := nr * blockSize fmt.Fprintf(w, "\t// Block %#x, offset %#x", nr, boff) var newline bool for i, c := range n.children { if i%8 == 0 { newline = true } if c != nil { v := b.Compactions[c.index.compaction].Offset + uint32(c.index.index) if v != 0 { if newline { fmt.Fprintf(w, "\n") newline = false } fmt.Fprintf(w, "\t%#02x:%#02x, ", boff+i, v) } } } return w.String() } var ( trieGen = template.Must(template.New("trie").Funcs(template.FuncMap{ "printValues": printValues, "printIndex": printIndex, "title": strings.Title, "dec": func(x int) int { return x - 1 }, "psize": func(n int) string { return fmt.Sprintf("%d bytes (%.2f KiB)", n, float64(n)/1024) }, }).Parse(trieTemplate)) lookupGen = template.Must(template.New("lookup").Parse(lookupTemplate)) ) // TODO: consider the return type of lookup. It could be uint64, even if the // internal value type is smaller. We will have to verify this with the // performance of unicode/norm, which is very sensitive to such changes. const trieTemplate = `{{$b := .}}{{$multi := gt (len .Trie) 1}} // {{.Name}}Trie. Total size: {{psize .Size}}. Checksum: {{printf "%08x" .Checksum}}. type {{.Name}}Trie struct { {{if $multi}} ascii []{{.ValueType}} // index for ASCII bytes utf8Start []{{.IndexType}} // index for UTF-8 bytes >= 0xC0 {{end}}} // func new{{title .Name}}Trie(i int) *{{.Name}}Trie { {{if $multi}} // h := {{.Name}}TrieHandles[i] // return &{{.Name}}Trie{ {{.Name}}Values[uint32(h.ascii)<<6:], {{.Name}}Index[uint32(h.multi)<<6:] } // } // // type {{.Name}}TrieHandle struct { // ascii, multi {{.IndexType}} // } // // // {{.Name}}TrieHandles: {{len .Trie}} handles, {{.Stats.NHandleBytes}} bytes // var {{.Name}}TrieHandles = [{{len .Trie}}]{{.Name}}TrieHandle{ // {{range .Trie}} { {{.ASCIIIndex}}, {{.StarterIndex}} }, // {{printf "%08x" .Checksum}}: {{.Name}} // {{end}}}{{else}} // return &{{.Name}}Trie{} // } {{end}} // lookupValue determines the type of block n and looks up the value for b. func (t *{{.Name}}Trie) lookupValue(n uint32, b byte) {{.ValueType}}{{$last := dec (len .Compactions)}} { switch { {{range $i, $c := .Compactions}} {{if eq $i $last}}default{{else}}case n < {{$c.Cutoff}}{{end}}:{{if ne $i 0}} n -= {{$c.Offset}}{{end}} return {{print $b.ValueType}}({{$c.Handler}}){{end}} } } // {{.Name}}Values: {{len .ValueBlocks}} blocks, {{.Stats.NValueEntries}} entries, {{.Stats.NValueBytes}} bytes // The third block is the zero block. var {{.Name}}Values = [{{.Stats.NValueEntries}}]{{.ValueType}} { {{range $i, $v := .ValueBlocks}}{{printValues $i $v}} {{end}}} // {{.Name}}Index: {{len .IndexBlocks}} blocks, {{.Stats.NIndexEntries}} entries, {{.Stats.NIndexBytes}} bytes // Block 0 is the zero block. var {{.Name}}Index = [{{.Stats.NIndexEntries}}]{{.IndexType}} { {{range $i, $v := .IndexBlocks}}{{printIndex $b $i $v}} {{end}}} ` // TODO: consider allowing zero-length strings after evaluating performance with // unicode/norm. const lookupTemplate = ` // lookup{{if eq .SourceType "string"}}String{{end}} 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 *{{.Name}}Trie) lookup{{if eq .SourceType "string"}}String{{end}}(s {{.SourceType}}) (v {{.ValueType}}, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return {{.ASCIIBlock}}[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := {{.StarterBlock}}[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := {{.StarterBlock}}[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = {{.Name}}Index[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := {{.StarterBlock}}[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = {{.Name}}Index[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = {{.Name}}Index[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } ` golang-github-clipperhouse-uax29-2.7.0/internal/gen/triegen/triegen.go000066400000000000000000000344441515045622700257430ustar00rootroot00000000000000// Copyright 2014 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 triegen implements a code generator for a trie for associating // unsigned integer values with UTF-8 encoded runes. // // Many of the go.text packages use tries for storing per-rune information. A // trie is especially useful if many of the runes have the same value. If this // is the case, many blocks can be expected to be shared allowing for // information on many runes to be stored in little space. // // As most of the lookups are done directly on []byte slices, the tries use the // UTF-8 bytes directly for the lookup. This saves a conversion from UTF-8 to // runes and contributes a little bit to better performance. It also naturally // provides a fast path for ASCII. // // Space is also an issue. There are many code points defined in Unicode and as // a result tables can get quite large. So every byte counts. The triegen // package automatically chooses the smallest integer values to represent the // tables. Compacters allow further compression of the trie by allowing for // alternative representations of individual trie blocks. // // triegen allows generating multiple tries as a single structure. This is // useful when, for example, one wants to generate tries for several languages // that have a lot of values in common. Some existing libraries for // internationalization store all per-language data as a dynamically loadable // chunk. The go.text packages are designed with the assumption that the user // typically wants to compile in support for all supported languages, in line // with the approach common to Go to create a single standalone binary. The // multi-root trie approach can give significant storage savings in this // scenario. // // triegen generates both tables and code. The code is optimized to use the // automatically chosen data types. The following code is generated for a Trie // or multiple Tries named "foo": // - type fooTrie // The trie type. // // - func newFooTrie(x int) *fooTrie // Trie constructor, where x is the index of the trie passed to Gen. // // - func (t *fooTrie) lookup(s []byte) (v uintX, sz int) // The lookup method, where uintX is automatically chosen. // // - func lookupString, lookupUnsafe and lookupStringUnsafe // Variants of the above. // // - var fooValues and fooIndex and any tables generated by Compacters. // The core trie data. // // - var fooTrieHandles // Indexes of starter blocks in case of multiple trie roots. // // It is recommended that users test the generated trie by checking the returned // value for every rune. Such exhaustive tests are possible as the number of // runes in Unicode is limited. package triegen // import "golang.org/x/text/internal/triegen" // TODO: Arguably, the internally optimized data types would not have to be // exposed in the generated API. We could also investigate not generating the // code, but using it through a package. We would have to investigate the impact // on performance of making such change, though. For packages like unicode/norm, // small changes like this could tank performance. import ( "encoding/binary" "fmt" "hash/crc64" "io" "log" "unicode/utf8" ) // builder builds a set of tries for associating values with runes. The set of // tries can share common index and value blocks. type builder struct { Name string // ValueType is the type of the trie values looked up. ValueType string // ValueSize is the byte size of the ValueType. ValueSize int // IndexType is the type of trie index values used for all UTF-8 bytes of // a rune except the last one. IndexType string // IndexSize is the byte size of the IndexType. IndexSize int // SourceType is used when generating the lookup functions. If the user // requests StringSupport, all lookup functions will be generated for // string input as well. SourceType string Trie []*Trie IndexBlocks []*node ValueBlocks [][]uint64 Compactions []compaction Checksum uint64 ASCIIBlock string StarterBlock string indexBlockIdx map[uint64]int valueBlockIdx map[uint64]nodeIndex asciiBlockIdx map[uint64]int // Stats are used to fill out the template. Stats struct { NValueEntries int NValueBytes int NIndexEntries int NIndexBytes int NHandleBytes int } err error } // A nodeIndex encodes the index of a node, which is defined by the compaction // which stores it and an index within the compaction. For internal nodes, the // compaction is always 0. type nodeIndex struct { compaction int index int } // compaction keeps track of stats used for the compaction. type compaction struct { c Compacter maxHandle uint32 totalSize int // Used by template-based generator and thus exported. Cutoff uint32 Offset uint32 Handler string } func (b *builder) setError(err error) { if b.err == nil { b.err = err } } // An Option can be passed to Gen. type Option func(b *builder) error // Compact configures the trie generator to use the given Compacter. func Compact(c Compacter) Option { return func(b *builder) error { b.Compactions = append(b.Compactions, compaction{ c: c, Handler: c.Handler() + "(n, b)"}) return nil } } // Gen writes Go code for a shared trie lookup structure to w for the given // Tries. The generated trie type will be called nameTrie. newNameTrie(x) will // return the *nameTrie for tries[x]. A value can be looked up by using one of // the various lookup methods defined on nameTrie. It returns the table size of // the generated trie. func Gen(w io.Writer, name string, tries []*Trie, opts ...Option) (sz int, err error) { // The index contains two dummy blocks, followed by the zero block. The zero // block is at offset 0x80, so that the offset for the zero block for // continuation bytes is 0. b := &builder{ Name: name, Trie: tries, IndexBlocks: []*node{{}, {}, {}}, Compactions: []compaction{{ Handler: name + "Values[n<<6+uint32(b)]", }}, // The 0 key in indexBlockIdx and valueBlockIdx is the hash of the zero // block. indexBlockIdx: map[uint64]int{0: 0}, valueBlockIdx: map[uint64]nodeIndex{0: {}}, asciiBlockIdx: map[uint64]int{}, } b.Compactions[0].c = (*simpleCompacter)(b) for _, f := range opts { if err := f(b); err != nil { return 0, err } } b.build() if b.err != nil { return 0, b.err } if err = b.print(w); err != nil { return 0, err } return b.Size(), nil } // A Trie represents a single root node of a trie. A builder may build several // overlapping tries at once. type Trie struct { root *node hiddenTrie } // hiddenTrie contains values we want to be visible to the template generator, // but hidden from the API documentation. type hiddenTrie struct { Name string Checksum uint64 ASCIIIndex int StarterIndex int } // NewTrie returns a new trie root. func NewTrie(name string) *Trie { return &Trie{ &node{ children: make([]*node, blockSize), values: make([]uint64, utf8.RuneSelf), }, hiddenTrie{Name: name}, } } // Gen is a convenience wrapper around the Gen func passing t as the only trie // and uses the name passed to NewTrie. It returns the size of the generated // tables. func (t *Trie) Gen(w io.Writer, opts ...Option) (sz int, err error) { return Gen(w, t.Name, []*Trie{t}, opts...) } // node is a node of the intermediate trie structure. type node struct { // children holds this node's children. It is always of length 64. // A child node may be nil. children []*node // values contains the values of this node. If it is non-nil, this node is // either a root or leaf node: // For root nodes, len(values) == 128 and it maps the bytes in [0x00, 0x7F]. // For leaf nodes, len(values) == 64 and it maps the bytes in [0x80, 0xBF]. values []uint64 index nodeIndex } // Insert associates value with the given rune. Insert will panic if a non-zero // value is passed for an invalid rune. func (t *Trie) Insert(r rune, value uint64) { if value == 0 { return } s := string(r) if []rune(s)[0] != r && value != 0 { // Note: The UCD tables will always assign what amounts to a zero value // to a surrogate. Allowing a zero value for an illegal rune allows // users to iterate over [0..MaxRune] without having to explicitly // exclude surrogates, which would be tedious. panic(fmt.Sprintf("triegen: non-zero value for invalid rune %U", r)) } if len(s) == 1 { // It is a root node value (ASCII). t.root.values[s[0]] = value return } n := t.root for ; len(s) > 1; s = s[1:] { if n.children == nil { n.children = make([]*node, blockSize) } p := s[0] % blockSize c := n.children[p] if c == nil { c = &node{} n.children[p] = c } if len(s) > 2 && c.values != nil { log.Fatalf("triegen: insert(%U): found internal node with values", r) } n = c } if n.values == nil { n.values = make([]uint64, blockSize) } if n.children != nil { log.Fatalf("triegen: insert(%U): found leaf node that also has child nodes", r) } n.values[s[0]-0x80] = value } // Size returns the number of bytes the generated trie will take to store. It // needs to be exported as it is used in the templates. func (b *builder) Size() int { // Index blocks. sz := len(b.IndexBlocks) * blockSize * b.IndexSize // Skip the first compaction, which represents the normal value blocks, as // its totalSize does not account for the ASCII blocks, which are managed // separately. sz += len(b.ValueBlocks) * blockSize * b.ValueSize for _, c := range b.Compactions[1:] { sz += c.totalSize } // TODO: this computation does not account for the fixed overhead of a using // a compaction, either code or data. As for data, though, the typical // overhead of data is in the order of bytes (2 bytes for cases). Further, // the savings of using a compaction should anyway be substantial for it to // be worth it. // For multi-root tries, we also need to account for the handles. if len(b.Trie) > 1 { sz += 2 * b.IndexSize * len(b.Trie) } return sz } func (b *builder) build() { // Compute the sizes of the values. var vmax uint64 for _, t := range b.Trie { vmax = maxValue(t.root, vmax) } b.ValueType, b.ValueSize = getIntType(vmax) // Compute all block allocations. // TODO: first compute the ASCII blocks for all tries and then the other // nodes. ASCII blocks are more restricted in placement, as they require two // blocks to be placed consecutively. Processing them first may improve // sharing (at least one zero block can be expected to be saved.) for _, t := range b.Trie { b.Checksum += b.buildTrie(t) } // Compute the offsets for all the Compacters. offset := uint32(0) for i := range b.Compactions { c := &b.Compactions[i] c.Offset = offset offset += c.maxHandle + 1 c.Cutoff = offset } // Compute the sizes of indexes. // TODO: different byte positions could have different sizes. So far we have // not found a case where this is beneficial. imax := uint64(b.Compactions[len(b.Compactions)-1].Cutoff) for _, ib := range b.IndexBlocks { if x := uint64(ib.index.index); x > imax { imax = x } } b.IndexType, b.IndexSize = getIntType(imax) } func maxValue(n *node, max uint64) uint64 { if n == nil { return max } for _, c := range n.children { max = maxValue(c, max) } for _, v := range n.values { if max < v { max = v } } return max } func getIntType(v uint64) (string, int) { switch { case v < 1<<8: return "property", 1 case v < 1<<16: return "property", 2 case v < 1<<32: return "property", 4 } return "property", 8 } const ( blockSize = 64 // Subtract two blocks to offset 0x80, the first continuation byte. blockOffset = 2 // Subtract three blocks to offset 0xC0, the first non-ASCII starter. rootBlockOffset = 3 ) var crcTable = crc64.MakeTable(crc64.ISO) func (b *builder) buildTrie(t *Trie) uint64 { n := t.root // Get the ASCII offset. For the first trie, the ASCII block will be at // position 0. hasher := crc64.New(crcTable) _ = binary.Write(hasher, binary.BigEndian, n.values) hash := hasher.Sum64() v, ok := b.asciiBlockIdx[hash] if !ok { v = len(b.ValueBlocks) b.asciiBlockIdx[hash] = v b.ValueBlocks = append(b.ValueBlocks, n.values[:blockSize], n.values[blockSize:]) if v == 0 { // Add the zero block at position 2 so that it will be assigned a // zero reference in the lookup blocks. // TODO: always do this? This would allow us to remove a check from // the trie lookup, but at the expense of extra space. Analyze // performance for unicode/norm. b.ValueBlocks = append(b.ValueBlocks, make([]uint64, blockSize)) } } t.ASCIIIndex = v // Compute remaining offsets. t.Checksum = b.computeOffsets(n, true) // We already subtracted the normal blockOffset from the index. Subtract the // difference for starter bytes. t.StarterIndex = n.index.index - (rootBlockOffset - blockOffset) return t.Checksum } func (b *builder) computeOffsets(n *node, root bool) uint64 { // For the first trie, the root lookup block will be at position 3, which is // the offset for UTF-8 non-ASCII starter bytes. first := len(b.IndexBlocks) == rootBlockOffset if first { b.IndexBlocks = append(b.IndexBlocks, n) } // We special-case the cases where all values recursively are 0. This allows // for the use of a zero block to which all such values can be directed. hash := uint64(0) if n.children != nil || n.values != nil { hasher := crc64.New(crcTable) for _, c := range n.children { var v uint64 if c != nil { v = b.computeOffsets(c, false) } _ = binary.Write(hasher, binary.BigEndian, v) } _ = binary.Write(hasher, binary.BigEndian, n.values) hash = hasher.Sum64() } if first { b.indexBlockIdx[hash] = rootBlockOffset - blockOffset } // Compacters don't apply to internal nodes. if n.children != nil { v, ok := b.indexBlockIdx[hash] if !ok { v = len(b.IndexBlocks) - blockOffset b.IndexBlocks = append(b.IndexBlocks, n) b.indexBlockIdx[hash] = v } n.index = nodeIndex{0, v} } else { h, ok := b.valueBlockIdx[hash] if !ok { bestI, bestSize := 0, blockSize*b.ValueSize for i, c := range b.Compactions[1:] { if sz, ok := c.c.Size(n.values); ok && bestSize > sz { bestI, bestSize = i+1, sz } } c := &b.Compactions[bestI] c.totalSize += bestSize v := c.c.Store(n.values) if c.maxHandle < v { c.maxHandle = v } h = nodeIndex{bestI, int(v)} b.valueBlockIdx[hash] = h } n.index = h } return hash } golang-github-clipperhouse-uax29-2.7.0/internal/iterators/000077500000000000000000000000001515045622700235545ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/internal/iterators/filter/000077500000000000000000000000001515045622700250415ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/internal/iterators/filter/filter.go000066400000000000000000000010201515045622700266460ustar00rootroot00000000000000package filter import ( "unicode" "unicode/utf8" ) type Func func([]byte) bool // AlphaNumeric is a filter which returns only tokens // that contain a Letter or Number, as defined by Unicode. var AlphaNumeric Func = func(token []byte) bool { pos := 0 for pos < len(token) { r, w := utf8.DecodeRune(token[pos:]) if unicode.IsLetter(r) || unicode.IsNumber(r) { // we use these methods instead of unicode.In for // performance; these methods have ASCII fast paths return true } pos += w } return false } golang-github-clipperhouse-uax29-2.7.0/internal/iterators/iterator.go000066400000000000000000000046151515045622700257420ustar00rootroot00000000000000package iterators type SplitFunc[T ~string | ~[]byte] func(T, bool) (int, T, error) // Iterator is a generic iterator for words that are either []byte or string. // Iterate while Next() is true, and access the word via Value(). type Iterator[T ~string | ~[]byte] struct { split SplitFunc[T] data T start int pos int } // New creates a new Iterator for the given data and SplitFunc. func New[T ~string | ~[]byte](split SplitFunc[T], data T) *Iterator[T] { return &Iterator[T]{ split: split, data: data, } } // SetText sets the text for the iterator to operate on, and resets all state. func (iter *Iterator[T]) SetText(data T) { iter.data = data iter.start = 0 iter.pos = 0 } // Split sets the SplitFunc for the Iterator. func (iter *Iterator[T]) Split(split SplitFunc[T]) { iter.split = split } // Next advances the iterator to the next token. It returns false when there // are no remaining tokens or an error occurred. func (iter *Iterator[T]) Next() bool { if iter.pos == len(iter.data) { return false } if iter.pos > len(iter.data) { panic("SplitFunc advanced beyond the end of the data") } iter.start = iter.pos d := iter.data[iter.pos:] if len(d) == 1 { // No need to split, just return the single byte iter.pos++ return true } advance, _, err := iter.split(d, true) if err != nil { panic(err) } if advance <= 0 { panic("SplitFunc returned a zero or negative advance") } iter.pos += advance if iter.pos > len(iter.data) { panic("SplitFunc advanced beyond the end of the data") } return true } // Value returns the current token. func (iter *Iterator[T]) Value() T { return iter.data[iter.start:iter.pos] } // Start returns the byte position of the current token in the original data. func (iter *Iterator[T]) Start() int { return iter.start } // End returns the byte position after the current token in the original data. func (iter *Iterator[T]) End() int { return iter.pos } // Reset resets the iterator to the beginning of the data. func (iter *Iterator[T]) Reset() { iter.start = 0 iter.pos = 0 } func (iter *Iterator[T]) First() T { if len(iter.data) == 0 { return iter.data } advance, _, err := iter.split(iter.data, true) if err != nil { panic(err) } if advance <= 0 { panic("SplitFunc returned a zero or negative advance") } if advance > len(iter.data) { panic("SplitFunc advanced beyond the end of the data") } return iter.data[:advance] } golang-github-clipperhouse-uax29-2.7.0/internal/iterators/iterator_test.go000066400000000000000000000575601515045622700270100ustar00rootroot00000000000000package iterators_test import ( "bytes" "testing" "github.com/clipperhouse/uax29/v2/internal/iterators" ) // simpleSpaceSplitString is a lossless SplitFunc that splits on spaces for strings // It treats contiguous spaces and contiguous non-spaces as separate tokens func simpleSpaceSplitString[T ~string | ~[]byte](data T, atEOF bool) (int, T, error) { if len(data) == 0 { return 0, data, nil } // Determine if we're starting with a space or non-space isSpace := data[0] == ' ' // Find the end of the current token (same type as start) i := 1 for i < len(data) && (data[i] == ' ') == isSpace { i++ } // Return the token and advance by its length token := data[:i] return len(token), token, nil } func TestIterator(t *testing.T) { tests := []struct { name string input string expected []string }{ { name: "empty string", input: "", expected: []string{}, }, { name: "single word", input: "hello", expected: []string{"hello"}, }, { name: "two words", input: "hello world", expected: []string{"hello", " ", "world"}, }, { name: "multiple words", input: "hello world test", expected: []string{"hello", " ", "world", " ", "test"}, }, { name: "words with multiple spaces", input: "hello world test", expected: []string{"hello", " ", "world", " ", "test"}, }, { name: "leading and trailing spaces", input: " hello world ", expected: []string{" ", "hello", " ", "world", " "}, }, { name: "only spaces", input: " ", expected: []string{" "}, }, { name: "unicode characters", input: "café naïve", expected: []string{"café", " ", "naïve"}, }, { name: "emoji and unicode", input: "hello 🌍 world", expected: []string{"hello", " ", "🌍", " ", "world"}, }, { name: "chinese characters", input: "你好 世界", expected: []string{"你好", " ", "世界"}, }, { name: "mixed unicode and spaces", input: " café naïve ", expected: []string{" ", "café", " ", "naïve", " "}, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Run("string", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[string], tt.input) var got []string for iter.Next() { got = append(got, iter.Value()) } if len(got) != len(tt.expected) { t.Errorf("expected %d tokens, got %d", len(tt.expected), len(got)) return } for i, expected := range tt.expected { if got[i] != expected { t.Errorf("token %d: expected %q, got %q", i, expected, got[i]) } } }) t.Run("[]byte", func(t *testing.T) { b := []byte(tt.input) iter := iterators.New(simpleSpaceSplitString[[]byte], b) var got [][]byte for iter.Next() { got = append(got, iter.Value()) } if len(got) != len(tt.expected) { t.Errorf("expected %d tokens, got %d", len(tt.expected), len(got)) return } for i, expected := range tt.expected { if !bytes.Equal(got[i], []byte(expected)) { t.Errorf("token %d: expected %q, got %q", i, expected, got[i]) } } }) t.Run("named_string", func(t *testing.T) { type MyString string iter := iterators.New(simpleSpaceSplitString[MyString], MyString(tt.input)) var got []MyString for iter.Next() { got = append(got, iter.Value()) } if len(got) != len(tt.expected) { t.Errorf("expected %d tokens, got %d", len(tt.expected), len(got)) return } for i, expected := range tt.expected { s := MyString(got[i]) if s != MyString(expected) { t.Errorf("token %d: expected %q, got %q", i, expected, got[i]) } } }) t.Run("named_bytes", func(t *testing.T) { type MyBytes []byte iter := iterators.New(simpleSpaceSplitString[MyBytes], MyBytes(tt.input)) var got []MyBytes for iter.Next() { got = append(got, iter.Value()) } if len(got) != len(tt.expected) { t.Errorf("expected %d tokens, got %d", len(tt.expected), len(got)) return } for i, expected := range tt.expected { if !bytes.Equal(got[i], []byte(expected)) { t.Errorf("token %d: expected %q, got %q", i, expected, got[i]) } } }) }) } } func TestIterator_Positions(t *testing.T) { tests := []struct { name string input string expected []struct { start, end int value string } }{ { name: "ascii", input: "hello world test", expected: []struct { start, end int value string }{ {0, 5, "hello"}, {5, 6, " "}, {6, 11, "world"}, {11, 12, " "}, {12, 16, "test"}, }, }, { name: "unicode", input: "café naïve", expected: []struct { start, end int value string }{ {0, 5, "café"}, // "café" is 5 bytes in UTF-8 {5, 6, " "}, // space is 1 byte {6, 12, "naïve"}, // "naïve" is 6 bytes in UTF-8 }, }, { name: "emoji", input: "hello 🌍 world", expected: []struct { start, end int value string }{ {0, 5, "hello"}, // "hello" is 5 bytes {5, 6, " "}, // space is 1 byte {6, 10, "🌍"}, // "🌍" is 4 bytes in UTF-8 {10, 11, " "}, // space is 1 byte {11, 16, "world"}, // "world" is 5 bytes }, }, { name: "chinese", input: "你好 世界", expected: []struct { start, end int value string }{ {0, 6, "你好"}, // "你好" is 6 bytes in UTF-8 {6, 7, " "}, // space is 1 byte {7, 13, "世界"}, // "世界" is 6 bytes in UTF-8 }, }, { name: "mixed_spaces", input: " café naïve ", expected: []struct { start, end int value string }{ {0, 2, " "}, // leading spaces {2, 7, "café"}, // "café" is 5 bytes {7, 9, " "}, // middle spaces {9, 15, "naïve"}, // "naïve" is 6 bytes {15, 17, " "}, // trailing spaces }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Run("string", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[string], tt.input) for i, expected := range tt.expected { if !iter.Next() { t.Fatalf("expected token %d but Next() returned false", i) } if iter.Start() != expected.start { t.Errorf("token %d: expected start %d, got %d", i, expected.start, iter.Start()) } if iter.End() != expected.end { t.Errorf("token %d: expected end %d, got %d", i, expected.end, iter.End()) } if iter.Value() != expected.value { t.Errorf("token %d: expected value %q, got %q", i, expected.value, iter.Value()) } } if iter.Next() { t.Error("expected Next() to return false after all tokens") } }) t.Run("[]byte", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[[]byte], []byte(tt.input)) for i, expected := range tt.expected { if !iter.Next() { t.Fatalf("expected token %d but Next() returned false", i) } if iter.Start() != expected.start { t.Errorf("token %d: expected start %d, got %d", i, expected.start, iter.Start()) } if iter.End() != expected.end { t.Errorf("token %d: expected end %d, got %d", i, expected.end, iter.End()) } if string(iter.Value()) != expected.value { t.Errorf("token %d: expected value %q, got %q", i, expected.value, iter.Value()) } } if iter.Next() { t.Error("expected Next() to return false after all tokens") } }) t.Run("named_string", func(t *testing.T) { type MyString string iter := iterators.New(simpleSpaceSplitString[MyString], MyString(tt.input)) for i, expected := range tt.expected { if !iter.Next() { t.Fatalf("expected token %d but Next() returned false", i) } if iter.Start() != expected.start { t.Errorf("token %d: expected start %d, got %d", i, expected.start, iter.Start()) } if iter.End() != expected.end { t.Errorf("token %d: expected end %d, got %d", i, expected.end, iter.End()) } if string(iter.Value()) != expected.value { t.Errorf("token %d: expected value %q, got %q", i, expected.value, iter.Value()) } } if iter.Next() { t.Error("expected Next() to return false after all tokens") } }) t.Run("named_bytes", func(t *testing.T) { type MyBytes []byte iter := iterators.New(simpleSpaceSplitString[MyBytes], MyBytes(tt.input)) for i, expected := range tt.expected { if !iter.Next() { t.Fatalf("expected token %d but Next() returned false", i) } if iter.Start() != expected.start { t.Errorf("token %d: expected start %d, got %d", i, expected.start, iter.Start()) } if iter.End() != expected.end { t.Errorf("token %d: expected end %d, got %d", i, expected.end, iter.End()) } if !bytes.Equal(iter.Value(), []byte(expected.value)) { t.Errorf("token %d: expected value %q, got %q", i, expected.value, iter.Value()) } } if iter.Next() { t.Error("expected Next() to return false after all tokens") } }) }) } } func TestIterator_Reset(t *testing.T) { input := "hello world" t.Run("string", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[string], input) // First iteration var first []string for iter.Next() { first = append(first, iter.Value()) } // Reset and iterate again iter.Reset() var second []string for iter.Next() { second = append(second, iter.Value()) } if len(first) != len(second) { t.Errorf("expected same number of tokens after reset, got %d vs %d", len(first), len(second)) } for i := range first { if first[i] != second[i] { t.Errorf("token %d: expected %q, got %q", i, first[i], second[i]) } } }) t.Run("[]byte", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[[]byte], []byte(input)) // First iteration var first [][]byte for iter.Next() { first = append(first, iter.Value()) } // Reset and iterate again iter.Reset() var second [][]byte for iter.Next() { second = append(second, iter.Value()) } if len(first) != len(second) { t.Errorf("expected same number of tokens after reset, got %d vs %d", len(first), len(second)) } for i := range first { if !bytes.Equal(first[i], second[i]) { t.Errorf("token %d: expected %q, got %q", i, first[i], second[i]) } } }) t.Run("named_string", func(t *testing.T) { type MyString string iter := iterators.New(simpleSpaceSplitString[MyString], MyString(input)) // First iteration var first []MyString for iter.Next() { first = append(first, iter.Value()) } // Reset and iterate again iter.Reset() var second []MyString for iter.Next() { second = append(second, iter.Value()) } if len(first) != len(second) { t.Errorf("expected same number of tokens after reset, got %d vs %d", len(first), len(second)) } for i := range first { if first[i] != second[i] { t.Errorf("token %d: expected %q, got %q", i, first[i], second[i]) } } }) t.Run("named_bytes", func(t *testing.T) { type MyBytes []byte iter := iterators.New(simpleSpaceSplitString[MyBytes], MyBytes(input)) // First iteration var first []MyBytes for iter.Next() { first = append(first, iter.Value()) } // Reset and iterate again iter.Reset() var second []MyBytes for iter.Next() { second = append(second, iter.Value()) } if len(first) != len(second) { t.Errorf("expected same number of tokens after reset, got %d vs %d", len(first), len(second)) } for i := range first { if !bytes.Equal(first[i], second[i]) { t.Errorf("token %d: expected %q, got %q", i, first[i], second[i]) } } }) } func TestIterator_SetText(t *testing.T) { t.Run("string", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[string], "hello world") // First iteration var first []string for iter.Next() { first = append(first, iter.Value()) } // Set new text iter.SetText("foo bar baz") var second []string for iter.Next() { second = append(second, iter.Value()) } expectedFirst := []string{"hello", " ", "world"} expectedSecond := []string{"foo", " ", "bar", " ", "baz"} if len(first) != len(expectedFirst) { t.Errorf("first iteration: expected %d tokens, got %d", len(expectedFirst), len(first)) } if len(second) != len(expectedSecond) { t.Errorf("second iteration: expected %d tokens, got %d", len(expectedSecond), len(second)) } for i, expected := range expectedFirst { if first[i] != expected { t.Errorf("first iteration token %d: expected %q, got %q", i, expected, first[i]) } } for i, expected := range expectedSecond { if second[i] != expected { t.Errorf("second iteration token %d: expected %q, got %q", i, expected, second[i]) } } }) t.Run("[]byte", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[[]byte], []byte("hello world")) // First iteration var first [][]byte for iter.Next() { first = append(first, iter.Value()) } // Set new text iter.SetText([]byte("foo bar baz")) var second [][]byte for iter.Next() { second = append(second, iter.Value()) } expectedFirst := [][]byte{[]byte("hello"), []byte(" "), []byte("world")} expectedSecond := [][]byte{[]byte("foo"), []byte(" "), []byte("bar"), []byte(" "), []byte("baz")} if len(first) != len(expectedFirst) { t.Errorf("first iteration: expected %d tokens, got %d", len(expectedFirst), len(first)) } if len(second) != len(expectedSecond) { t.Errorf("second iteration: expected %d tokens, got %d", len(expectedSecond), len(second)) } for i, expected := range expectedFirst { if !bytes.Equal(first[i], expected) { t.Errorf("first iteration token %d: expected %q, got %q", i, expected, first[i]) } } for i, expected := range expectedSecond { if !bytes.Equal(second[i], expected) { t.Errorf("second iteration token %d: expected %q, got %q", i, expected, second[i]) } } }) t.Run("named_string", func(t *testing.T) { type MyString string iter := iterators.New(simpleSpaceSplitString[MyString], MyString("hello world")) // First iteration var first []MyString for iter.Next() { first = append(first, iter.Value()) } // Set new text iter.SetText(MyString("foo bar baz")) var second []MyString for iter.Next() { second = append(second, iter.Value()) } expectedFirst := []MyString{"hello", " ", "world"} expectedSecond := []MyString{"foo", " ", "bar", " ", "baz"} if len(first) != len(expectedFirst) { t.Errorf("first iteration: expected %d tokens, got %d", len(expectedFirst), len(first)) } if len(second) != len(expectedSecond) { t.Errorf("second iteration: expected %d tokens, got %d", len(expectedSecond), len(second)) } for i, expected := range expectedFirst { if first[i] != expected { t.Errorf("first iteration token %d: expected %q, got %q", i, expected, first[i]) } } for i, expected := range expectedSecond { if second[i] != expected { t.Errorf("second iteration token %d: expected %q, got %q", i, expected, second[i]) } } }) t.Run("named_bytes", func(t *testing.T) { type MyBytes []byte iter := iterators.New(simpleSpaceSplitString[MyBytes], MyBytes("hello world")) // First iteration var first []MyBytes for iter.Next() { first = append(first, iter.Value()) } // Set new text iter.SetText(MyBytes("foo bar baz")) var second []MyBytes for iter.Next() { second = append(second, iter.Value()) } expectedFirst := []MyBytes{MyBytes("hello"), MyBytes(" "), MyBytes("world")} expectedSecond := []MyBytes{MyBytes("foo"), MyBytes(" "), MyBytes("bar"), MyBytes(" "), MyBytes("baz")} if len(first) != len(expectedFirst) { t.Errorf("first iteration: expected %d tokens, got %d", len(expectedFirst), len(first)) } if len(second) != len(expectedSecond) { t.Errorf("second iteration: expected %d tokens, got %d", len(expectedSecond), len(second)) } for i, expected := range expectedFirst { if !bytes.Equal(first[i], expected) { t.Errorf("first iteration token %d: expected %q, got %q", i, expected, first[i]) } } for i, expected := range expectedSecond { if !bytes.Equal(second[i], expected) { t.Errorf("second iteration token %d: expected %q, got %q", i, expected, second[i]) } } }) } func TestIterator_EmptyTokens(t *testing.T) { // Test that empty tokens are handled correctly input := "a b c" expected := []string{"a", " ", "b", " ", "c"} t.Run("string", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[string], input) var tokens []string for iter.Next() { tokens = append(tokens, iter.Value()) } if len(tokens) != len(expected) { t.Errorf("expected %d tokens, got %d", len(expected), len(tokens)) } for i, expected := range expected { if tokens[i] != expected { t.Errorf("token %d: expected %q, got %q", i, expected, tokens[i]) } } }) t.Run("[]byte", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[[]byte], []byte(input)) var tokens [][]byte for iter.Next() { tokens = append(tokens, iter.Value()) } if len(tokens) != len(expected) { t.Errorf("expected %d tokens, got %d", len(expected), len(tokens)) } for i, expected := range expected { if string(tokens[i]) != expected { t.Errorf("token %d: expected %q, got %q", i, expected, tokens[i]) } } }) t.Run("named_string", func(t *testing.T) { type MyString string iter := iterators.New(simpleSpaceSplitString[MyString], MyString(input)) var tokens []MyString for iter.Next() { tokens = append(tokens, iter.Value()) } if len(tokens) != len(expected) { t.Errorf("expected %d tokens, got %d", len(expected), len(tokens)) } for i, expected := range expected { if string(tokens[i]) != expected { t.Errorf("token %d: expected %q, got %q", i, expected, tokens[i]) } } }) t.Run("named_bytes", func(t *testing.T) { type MyBytes []byte iter := iterators.New(simpleSpaceSplitString[MyBytes], MyBytes(input)) var tokens []MyBytes for iter.Next() { tokens = append(tokens, iter.Value()) } if len(tokens) != len(expected) { t.Errorf("expected %d tokens, got %d", len(expected), len(tokens)) } for i, expected := range expected { if string(tokens[i]) != expected { t.Errorf("token %d: expected %q, got %q", i, expected, tokens[i]) } } }) } func TestIterator_ValueBeforeNext(t *testing.T) { input := "hello world" t.Run("string", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[string], input) // Value() before Next() should return zero value var zero string if iter.Value() != zero { t.Errorf("expected zero value before Next(), got %q", iter.Value()) } // After Next(), should return the actual value if !iter.Next() { t.Fatal("expected Next() to return true") } if iter.Value() != "hello" { t.Errorf("expected %q, got %q", "hello", iter.Value()) } }) t.Run("[]byte", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[[]byte], []byte(input)) // Value() before Next() should return zero value var zero []byte if string(iter.Value()) != string(zero) { t.Errorf("expected zero value before Next(), got %q", iter.Value()) } // After Next(), should return the actual value if !iter.Next() { t.Fatal("expected Next() to return true") } if string(iter.Value()) != "hello" { t.Errorf("expected %q, got %q", "hello", iter.Value()) } }) t.Run("named_string", func(t *testing.T) { type MyString string iter := iterators.New(simpleSpaceSplitString[MyString], MyString(input)) // Value() before Next() should return zero value var zero MyString if iter.Value() != zero { t.Errorf("expected zero value before Next(), got %q", iter.Value()) } // After Next(), should return the actual value if !iter.Next() { t.Fatal("expected Next() to return true") } if string(iter.Value()) != "hello" { t.Errorf("expected %q, got %q", "hello", iter.Value()) } }) t.Run("named_bytes", func(t *testing.T) { type MyBytes []byte iter := iterators.New(simpleSpaceSplitString[MyBytes], MyBytes(input)) // Value() before Next() should return zero value var zero MyBytes if string(iter.Value()) != string(zero) { t.Errorf("expected zero value before Next(), got %q", iter.Value()) } // After Next(), should return the actual value if !iter.Next() { t.Fatal("expected Next() to return true") } if string(iter.Value()) != "hello" { t.Errorf("expected %q, got %q", "hello", iter.Value()) } }) } func TestIterator_StartEndBeforeNext(t *testing.T) { input := "hello world" t.Run("string", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[string], input) // Start() and End() before Next() should return 0 if iter.Start() != 0 { t.Errorf("expected Start() to return 0 before Next(), got %d", iter.Start()) } if iter.End() != 0 { t.Errorf("expected End() to return 0 before Next(), got %d", iter.End()) } // After Next(), should return actual positions if !iter.Next() { t.Fatal("expected Next() to return true") } if iter.Start() != 0 { t.Errorf("expected Start() to return 0, got %d", iter.Start()) } if iter.End() != 5 { t.Errorf("expected End() to return 5, got %d", iter.End()) } }) t.Run("[]byte", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[[]byte], []byte(input)) // Start() and End() before Next() should return 0 if iter.Start() != 0 { t.Errorf("expected Start() to return 0 before Next(), got %d", iter.Start()) } if iter.End() != 0 { t.Errorf("expected End() to return 0 before Next(), got %d", iter.End()) } // After Next(), should return actual positions if !iter.Next() { t.Fatal("expected Next() to return true") } if iter.Start() != 0 { t.Errorf("expected Start() to return 0, got %d", iter.Start()) } if iter.End() != 5 { t.Errorf("expected End() to return 5, got %d", iter.End()) } }) t.Run("named_string", func(t *testing.T) { type MyString string iter := iterators.New(simpleSpaceSplitString[MyString], MyString(input)) // Start() and End() before Next() should return 0 if iter.Start() != 0 { t.Errorf("expected Start() to return 0 before Next(), got %d", iter.Start()) } if iter.End() != 0 { t.Errorf("expected End() to return 0 before Next(), got %d", iter.End()) } // After Next(), should return actual positions if !iter.Next() { t.Fatal("expected Next() to return true") } if iter.Start() != 0 { t.Errorf("expected Start() to return 0, got %d", iter.Start()) } if iter.End() != 5 { t.Errorf("expected End() to return 5, got %d", iter.End()) } }) t.Run("named_bytes", func(t *testing.T) { type MyBytes []byte iter := iterators.New(simpleSpaceSplitString[MyBytes], MyBytes(input)) // Start() and End() before Next() should return 0 if iter.Start() != 0 { t.Errorf("expected Start() to return 0 before Next(), got %d", iter.Start()) } if iter.End() != 0 { t.Errorf("expected End() to return 0 before Next(), got %d", iter.End()) } // After Next(), should return actual positions if !iter.Next() { t.Fatal("expected Next() to return true") } if iter.Start() != 0 { t.Errorf("expected Start() to return 0, got %d", iter.Start()) } if iter.End() != 5 { t.Errorf("expected End() to return 5, got %d", iter.End()) } }) } func TestIterator_First(t *testing.T) { input := "héllo world" t.Run("string", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[string], input) if iter.First() != "héllo" { t.Errorf("expected %q, got %q", "héllo", iter.First()) } }) t.Run("[]byte", func(t *testing.T) { iter := iterators.New(simpleSpaceSplitString[[]byte], []byte(input)) if string(iter.First()) != "héllo" { t.Errorf("expected %q, got %q", "héllo", iter.First()) } }) t.Run("named_string", func(t *testing.T) { type MyString string iter := iterators.New(simpleSpaceSplitString[MyString], MyString(input)) if iter.First() != MyString("héllo") { t.Errorf("expected %q, got %q", "héllo", iter.First()) } }) } golang-github-clipperhouse-uax29-2.7.0/phrases/000077500000000000000000000000001515045622700213715ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/phrases/README.md000066400000000000000000000052521515045622700226540ustar00rootroot00000000000000An implementation of "phrase boundaries", a variation on words boundaries from [Unicode text segmentation](https://unicode.org/reports/tr29/#Word_Boundaries) (UAX 29), for Unicode 17. "Phrases" are not a Unicode standard, it is our definition that we think may be useful. We define it as "a series of words separated only by spaces". Punctuation breaks phrases. Emojis are treated as words. [![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/uax29/v2/phrases.svg)](https://pkg.go.dev/github.com/clipperhouse/uax29/v2/phrases) ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg) ## Quick start ``` go get "github.com/clipperhouse/uax29/v2/phrases" ``` ```go import "github.com/clipperhouse/uax29/v2/phrases" text := "Hello, 世界. Nice — and totally adorable — dog; perhaps the "best one"! 🏆 🐶" tokens := phrases.FromString(text) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current phrase } ``` ## APIs ### If you have a `string` ```go text := "Hello, 世界. Nice dog! 👍🐶" tokens := phrases.FromString(text) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current phrase } ``` ### If you have an `io.Reader` `FromReader` embeds a [`bufio.Scanner`](https://pkg.go.dev/bufio#Scanner), so just use those methods. ```go r := getYourReader() // from a file or network maybe tokens := phrases.FromReader(r) for tokens.Scan() { // Scan() returns true until error or EOF fmt.Println(tokens.Text()) // Do something with the current phrase } if tokens.Err() != nil { // Check the error log.Fatal(tokens.Err()) } ``` ### If you have a `[]byte` ```go b := []byte("Hello, 世界. Nice dog! 👍🐶") tokens := phrases.FromBytes(b) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current phrase } ``` ### Performance On a Mac M2 laptop, we see around 240MB/s, or around 30 million phrases (tokens, really) per second. You should see ~constant memory, and no allocations. ### Invalid inputs Invalid UTF-8 input is considered undefined behavior. We test to ensure that bad inputs will not cause pathological outcomes, such as a panic or infinite loop. Callers should expect "garbage-in, garbage-out". Your pipeline should probably include a call to [`utf8.Valid()`](https://pkg.go.dev/unicode/utf8#Valid). golang-github-clipperhouse-uax29-2.7.0/phrases/bytes_test.go000066400000000000000000000051551515045622700241130ustar00rootroot00000000000000package phrases_test import ( "bytes" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/phrases" "github.com/clipperhouse/uax29/v2/testdata" ) func TestBytesRoundtrip(t *testing.T) { t.Parallel() const runs = 100 tokens := phrases.FromBytes(nil) for i := 0; i < runs; i++ { input := getRandomBytes() tokens.SetText(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatal("input bytes are not the same as output bytes") } } } func TestBytesInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } tokens := phrases.FromBytes(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as output bytes") } } var exists = struct{}{} func bytesToSetTrimmed(tokens *phrases.Iterator[[]byte]) map[string]struct{} { founds := make(map[string]struct{}) for tokens.Next() { key := bytes.TrimSpace(tokens.Value()) founds[string(key)] = exists } return founds } func TestPhraseBoundaries(t *testing.T) { t.Parallel() input := []byte("This should break here. And then here. 世界. I think, perhaps you can understand that — aside 🏆 🐶 here — “a quote”.") tokens := phrases.FromBytes(input) got := bytesToSetTrimmed(tokens) expecteds := map[string]struct{}{ "This should break here": exists, "And then here": exists, "世": exists, // We don't have great logic for languages without spaces. Also true for words, see Notes: https://unicode.org/reports/tr29/#WB999 "I think": exists, "perhaps you can understand that": exists, "aside 🏆 🐶 here": exists, "a quote": exists, } for phrase := range expecteds { _, found := got[phrase] if !found { t.Fatalf("phrase %q was expected, not found", phrase) } } } func BenchmarkBytesMultilingual(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } b.ResetTimer() bytes := len(file) b.SetBytes(int64(bytes)) c := 0 for i := 0; i < b.N; i++ { tokens := phrases.FromBytes(file) for tokens.Next() { _ = tokens.Value() c++ } } } golang-github-clipperhouse-uax29-2.7.0/phrases/fuzz_test.go000066400000000000000000000062001515045622700237530ustar00rootroot00000000000000package phrases_test import ( "bytes" mathrand "math/rand" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/phrases" "github.com/clipperhouse/uax29/v2/testdata" ) // FuzzValidShort fuzzes small, valid UTF8 strings. I suspect more, shorter // strings in the corpus lead to more mutation and coverage. True? func FuzzValidShort(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } // multi-lingual text, as small-ish lines file, err := testdata.Sample() if err != nil { f.Error(err) } lines := bytes.Split(file, []byte("\n")) for _, line := range lines { f.Add(line) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := phrases.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzValidLong fuzzes longer, valid UTF8 strings. func FuzzValidLong(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } // add multi-lingual text, as decent (paragraph-sized) size chunks file, err := testdata.Sample() if err != nil { f.Error(err) } chunks := bytes.Split(file, []byte("\n\n\n")) for _, chunk := range chunks { f.Add(chunk) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := phrases.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzInvalid fuzzes invalid UTF8 strings. func FuzzInvalid(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } random := getRandomBytes() const max = 100 const min = 1 pos := 0 for { // random smaller strings ln := mathrand.Intn(max-min) + min if pos+ln > len(random) { break } f.Add(random[pos : pos+ln]) pos += ln } // known invalid utf-8 badUTF8, err := testdata.InvalidUTF8() if err != nil { f.Error(err) } lines := bytes.Split(badUTF8, []byte("\n")) for _, line := range lines { f.Add(line) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := phrases.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } golang-github-clipperhouse-uax29-2.7.0/phrases/iterator.go000066400000000000000000000057011515045622700235540ustar00rootroot00000000000000package phrases // FromString returns an iterator for the phrases in the input string. // Iterate while Next() is true, and access the phrase via Value(). func FromString(s string) *Iterator[string] { return &Iterator[string]{ split: splitFuncString, data: s, } } // FromBytes returns an iterator for the phrases in the input bytes. // Iterate while Next() is true, and access the phrase via Value(). func FromBytes(b []byte) *Iterator[[]byte] { return &Iterator[[]byte]{ split: splitFuncBytes, data: b, } } // Iterator is a generic iterator for phrases in strings or byte slices. type Iterator[T ~string | ~[]byte] struct { split func(T, bool) (int, T, error) data T pos int start int } var ( splitFuncString = splitFunc[string] splitFuncBytes = splitFunc[[]byte] ) // isASCIIAlphanumericOrSpace returns true if b is in [a-zA-Z0-9 ] func isASCIIAlphanumericOrSpace(b byte) bool { return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9') || b == ' ' } // Next advances the iterator to the next phrase. // Returns false when there are no more phrases. func (iter *Iterator[T]) Next() bool { if iter.pos >= len(iter.data) { return false } iter.start = iter.pos // ASCII hot path: skip contiguous ASCII alphanumerics and spaces // These characters are guaranteed to stay together in a phrase (per WB8-10) for iter.pos < len(iter.data) && isASCIIAlphanumericOrSpace(iter.data[iter.pos]) { iter.pos++ } // If we consumed all remaining data, we're done if iter.pos >= len(iter.data) { return true } // If we skipped any ASCII, back up one so splitfunc has "last" context if iter.pos > iter.start { iter.pos-- } // Defer to splitfunc for the rest remaining := iter.data[iter.pos:] advance, _, err := iter.split(remaining, true) if err != nil { panic(err) } if advance <= 0 { panic("splitFunc returned a zero or negative advance") } iter.pos += advance if iter.pos > len(iter.data) { panic("splitFunc advanced beyond end of data") } return true } // Value returns the current phrase. func (iter *Iterator[T]) Value() T { return iter.data[iter.start:iter.pos] } // Start returns the byte position of the current phrase in the original data. func (iter *Iterator[T]) Start() int { return iter.start } // End returns the byte position after the current phrase in the original data. func (iter *Iterator[T]) End() int { return iter.pos } // Reset resets the iterator to the beginning of the data. func (iter *Iterator[T]) Reset() { iter.start = 0 iter.pos = 0 } // SetText sets the data for the iterator to operate on, and resets all state. func (iter *Iterator[T]) SetText(data T) { iter.data = data iter.start = 0 iter.pos = 0 } // First returns the first phrase without advancing the iterator. func (iter *Iterator[T]) First() T { if len(iter.data) == 0 { return iter.data } // Use a copy to leverage Next()'s ASCII optimization cp := *iter cp.pos = 0 cp.start = 0 cp.Next() return cp.Value() } golang-github-clipperhouse-uax29-2.7.0/phrases/reader.go000066400000000000000000000011071515045622700231610ustar00rootroot00000000000000// Package phrases implements Unicode phrase boundaries: https://unicode.org/reports/tr29/#phrase_Boundaries package phrases import ( "bufio" "io" ) type Scanner struct { *bufio.Scanner } // FromReader returns a Scanner, to split phrases. "Phrase" is defined as // a series of words separated only by spaces. // // It embeds a [bufio.Scanner], so you can use its methods. // // Iterate through phrases by calling Scan() until false, then check Err(). func FromReader(r io.Reader) *Scanner { sc := bufio.NewScanner(r) sc.Split(SplitFunc) return &Scanner{ Scanner: sc, } } golang-github-clipperhouse-uax29-2.7.0/phrases/reader_test.go000066400000000000000000000054111515045622700242220ustar00rootroot00000000000000package phrases_test import ( "bytes" "crypto/rand" mathrand "math/rand" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/phrases" "github.com/clipperhouse/uax29/v2/testdata" ) func TestScannerRoundtrip(t *testing.T) { t.Parallel() const runs = 100 for i := 0; i < runs; i++ { input := getRandomBytes() r := bytes.NewReader(input) sc := phrases.FromReader(r) var output []byte for sc.Scan() { output = append(output, sc.Bytes()...) } if err := sc.Err(); err != nil { t.Fatal(err) } if !bytes.Equal(output, input) { t.Fatal("input bytes are not the same as scanned bytes") } } } func TestInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } r := bytes.NewReader(input) sc := phrases.FromReader(r) var output []byte for sc.Scan() { output = append(output, sc.Bytes()...) } if err := sc.Err(); err != nil { t.Error(err) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as scanned bytes") } } func TestNeverZeroAtEOF(t *testing.T) { t.Parallel() // SplitFunc should never return advance = 0 when atEOF. This test is redundant // with the roundtrip test above, but nice to call out this invariant. const runs = 100 atEOF := true for i := 0; i < runs; i++ { input := getRandomBytes() advance, _, _ := phrases.SplitFunc(input, atEOF) if advance == 0 { t.Errorf("advance should never be zero (atEOF %t)", atEOF) } } } func TestNeverErr(t *testing.T) { t.Parallel() // SplitFunc should never return an error. This test is redundant // with the roundtrip test above, but nice to call out this invariant. const runs = 100 atEOFs := []bool{true, false} for i := 0; i < runs; i++ { for _, atEOF := range atEOFs { input := getRandomBytes() _, _, err := phrases.SplitFunc(input, atEOF) if err != nil { t.Errorf("SplitFunc should never error (atEOF %t)", atEOF) } } } } func getRandomBytes() []byte { const max = 10000 const min = 1 len := mathrand.Intn(max-min) + min b := make([]byte, len) _, err := rand.Read(b) if err != nil { panic(err) } return b } func BenchmarkScannerMultilingual(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } b.ResetTimer() b.SetBytes(int64(len(file))) r := bytes.NewReader(file) for i := 0; i < b.N; i++ { r.Reset(file) sc := phrases.FromReader(r) c := 0 for sc.Scan() { c++ } if err := sc.Err(); err != nil { b.Error(err) } } } golang-github-clipperhouse-uax29-2.7.0/phrases/seek.go000066400000000000000000000020101515045622700226400ustar00rootroot00000000000000package phrases const notfound = -1 // subsequent looks ahead in the buffer until it hits a rune in properties, // ignoring runes with the _Ignore property per WB4 func subsequent[T ~string | ~[]byte](properties property, data T, atEOF bool) (advance int, more bool) { i := 0 for i < len(data) { lookup, w := lookup(data[i:]) if w == 0 { if atEOF { // Nothing more to evaluate return notfound, false } // More to evaluate - return notfound to indicate no match found yet return notfound, true } if lookup.is(_Ignore) { i += w continue } if lookup.is(properties) { // Found it return i, false } // If we see a non-ignored character that doesn't match, // the property is definitely not "immediately subsequent" return notfound, false } // If we reach here, we've only seen ignored characters or incomplete runes if atEOF { // Nothing more to evaluate return notfound, false } // Need more - return notfound to indicate no match found yet return notfound, true } golang-github-clipperhouse-uax29-2.7.0/phrases/seek_test.go000066400000000000000000000075311515045622700237140ustar00rootroot00000000000000package phrases import ( "testing" ) func TestSubsequent(t *testing.T) { tests := []struct { name string properties property data []byte atEOF bool expectAdvance int expectMore bool description string }{ // Basic found cases { name: "found_immediately", properties: _Numeric, data: []byte("123"), atEOF: true, expectAdvance: 0, expectMore: false, description: "Should find numeric character at start", }, { name: "found_after_ignored_chars", properties: _Numeric, data: []byte("\u200d1"), // ZWJ + '1' atEOF: true, expectAdvance: 3, // ZWJ is 3 bytes expectMore: false, description: "Should skip ignored ZWJ and find numeric", }, { name: "not_found_definitive", properties: _Numeric, data: []byte("abc"), atEOF: true, expectAdvance: notfound, expectMore: false, description: "Should not find numeric in letters", }, { name: "not_found_immediate_non_match", properties: _Numeric, data: []byte("a"), atEOF: true, expectAdvance: notfound, expectMore: false, description: "Should not find numeric in single letter", }, { name: "empty_data_at_eof", properties: _Numeric, data: []byte(""), atEOF: true, expectAdvance: notfound, expectMore: false, description: "Empty data at EOF should return not found", }, { name: "empty_data_not_at_eof", properties: _Numeric, data: []byte(""), atEOF: false, expectAdvance: notfound, expectMore: true, description: "Empty data not at EOF should request more data", }, { name: "only_ignored_at_eof", properties: _Numeric, data: []byte("\u200d"), // ZWJ only atEOF: true, expectAdvance: notfound, expectMore: false, description: "Only ignored chars at EOF should return not found", }, { name: "only_ignored_not_at_eof", properties: _Numeric, data: []byte("\u200d"), // ZWJ only atEOF: false, expectAdvance: notfound, expectMore: true, description: "Only ignored chars not at EOF should request more data", }, { name: "incomplete_rune_at_eof", properties: _Numeric, data: []byte{0xE2, 0x80}, // Incomplete ZWJ (needs 3 bytes) atEOF: true, expectAdvance: notfound, expectMore: false, description: "Incomplete rune at EOF should return not found", }, { name: "incomplete_rune_not_at_eof", properties: _Numeric, data: []byte{0xE2, 0x80}, // Incomplete ZWJ atEOF: false, expectAdvance: notfound, expectMore: true, description: "Incomplete rune not at EOF should request more data", }, { name: "ignored_then_found", properties: _ALetter, data: []byte("\u200d\u200da"), // ZWJ + ZWJ + 'a' atEOF: true, expectAdvance: 6, // Two ZWJs = 6 bytes expectMore: false, description: "Should skip multiple ignored chars and find letter", }, { name: "find_any_of_multiple_properties", properties: _Numeric | _ALetter, data: []byte("a"), atEOF: true, expectAdvance: 0, expectMore: false, description: "Should find any matching property", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { advance, more := subsequent(tt.properties, tt.data, tt.atEOF) if advance != tt.expectAdvance { t.Errorf("advance = %d, expected %d\nDescription: %s", advance, tt.expectAdvance, tt.description) } if more != tt.expectMore { t.Errorf("more = %v, expected %v\nDescription: %s", more, tt.expectMore, tt.description) } }) } } golang-github-clipperhouse-uax29-2.7.0/phrases/splitfunc.go000066400000000000000000000140401515045622700237260ustar00rootroot00000000000000package phrases import ( "bufio" ) // is determines if lookup intersects propert(ies) func (lookup property) is(properties property) bool { return (lookup & properties) != 0 } const ( _AHLetter = _ALetter | _HebrewLetter | _ExtendedPictographic // _ExtendedPictographic is added for phrases (vs words) _MidNumLetQ = _MidNumLet | _SingleQuote _Ignore = _Extend | _Format | _ZWJ ) // SplitFunc is a bufio.SplitFunc implementation of phrase segmentation, for use with bufio.Scanner. var SplitFunc bufio.SplitFunc = splitFunc[[]byte] // splitFunc is a bufio.SplitFunc implementation of phrase segmentation, for use with bufio.Scanner. func splitFunc[T ~string | ~[]byte](data T, atEOF bool) (advance int, token T, err error) { var empty T if len(data) == 0 { return 0, empty, nil } // These vars are stateful across loop iterations var pos int var lastExIgnore property // "last excluding ignored categories" var lastLastExIgnore property // "the last one before that" var regionalIndicatorCount int // Rules are usually of the form Cat1 × Cat2; "current" refers to the first property // to the right of the ×, from which we look back or forward current, w := lookup(data[pos:]) if w == 0 { if !atEOF { // Rune extends past current data, request more return 0, empty, nil } pos = len(data) return pos, data[:pos], nil } // https://unicode.org/reports/tr29/#WB1 // Start of text always advances pos += w for { eot := pos == len(data) // "end of text" if eot { if !atEOF { // Token extends past current data, request more return 0, empty, nil } // https://unicode.org/reports/tr29/#WB2 break } // Remember previous properties to avoid lookups/lookbacks last := current if !last.is(_Ignore) { lastLastExIgnore = lastExIgnore lastExIgnore = last } current, w = lookup(data[pos:]) if w == 0 { if atEOF { // Just return the bytes, we can't do anything with them pos = len(data) break } // Rune extends past current data, request more return 0, empty, nil } // Optimization: no rule can possibly apply if current|last == 0 { // i.e. both are zero break } // https://unicode.org/reports/tr29/#WB3 if current.is(_LF) && last.is(_CR) { pos += w continue } // https://unicode.org/reports/tr29/#WB3a // https://unicode.org/reports/tr29/#WB3b if (last | current).is(_Newline | _CR | _LF) { break } // https://unicode.org/reports/tr29/#WB3c if current.is(_ExtendedPictographic) && last.is(_ZWJ) { pos += w continue } // https://unicode.org/reports/tr29/#WB3d if (current & last).is(_WSegSpace) { pos += w continue } // https://unicode.org/reports/tr29/#WB4 if current.is(_Extend | _Format | _ZWJ) { pos += w continue } // WB4 applies to subsequent rules; there is an implied "ignoring Extend & Format & ZWJ" // https://unicode.org/reports/tr29/#Grapheme_Cluster_and_Format_Rules // The previous/subsequent methods are shorthand for "seek a property but skip over Extend|Format|ZWJ on the way" // https://unicode.org/reports/tr29/#WB5 if current.is(_AHLetter) && lastExIgnore.is(_AHLetter) { pos += w continue } // https://unicode.org/reports/tr29/#WB6 if current.is(_MidLetter|_MidNumLetQ) && lastExIgnore.is(_AHLetter) { advance, more := subsequent(_AHLetter, data[pos+w:], atEOF) if more { // Token extends past current data, request more return 0, empty, nil } if advance != notfound { pos += w + advance continue } } // https://unicode.org/reports/tr29/#WB7 if current.is(_AHLetter) && lastExIgnore.is(_MidLetter|_MidNumLetQ) && lastLastExIgnore.is(_AHLetter) { pos += w continue } // https://unicode.org/reports/tr29/#WB7a if current.is(_SingleQuote) && lastExIgnore.is(_HebrewLetter) { pos += w continue } // https://unicode.org/reports/tr29/#WB7b if current.is(_DoubleQuote) && lastExIgnore.is(_HebrewLetter) { advance, more := subsequent(_HebrewLetter, data[pos+w:], atEOF) if more { // Token extends past current data, request more return 0, empty, nil } if advance != notfound { pos += w + advance continue } } // https://unicode.org/reports/tr29/#WB7c if current.is(_HebrewLetter) && lastExIgnore.is(_DoubleQuote) && lastLastExIgnore.is(_HebrewLetter) { pos += w continue } // https://unicode.org/reports/tr29/#WB8 // https://unicode.org/reports/tr29/#WB9 // https://unicode.org/reports/tr29/#WB10 // _WSegSpace is added for phrases: treat spaces adjacent to words as non-breaking. if current.is(_Numeric|_AHLetter|_WSegSpace) && lastExIgnore.is(_Numeric|_AHLetter|_WSegSpace) { pos += w continue } // https://unicode.org/reports/tr29/#WB11 if current.is(_Numeric) && lastExIgnore.is(_MidNum|_MidNumLetQ) && lastLastExIgnore.is(_Numeric) { pos += w continue } // https://unicode.org/reports/tr29/#WB12 if current.is(_MidNum|_MidNumLetQ) && lastExIgnore.is(_Numeric) { advance, more := subsequent(_Numeric, data[pos+w:], atEOF) if more { // Token extends past current data, request more return 0, empty, nil } if advance != notfound { pos += w + advance continue } } // https://unicode.org/reports/tr29/#WB13 if current.is(_Katakana) && lastExIgnore.is(_Katakana) { pos += w continue } // https://unicode.org/reports/tr29/#WB13a if current.is(_ExtendNumLet) && lastExIgnore.is(_AHLetter|_Numeric|_Katakana|_ExtendNumLet) { pos += w continue } // https://unicode.org/reports/tr29/#WB13b if current.is(_AHLetter|_Numeric|_Katakana) && lastExIgnore.is(_ExtendNumLet) { pos += w continue } // https://unicode.org/reports/tr29/#WB15 and // https://unicode.org/reports/tr29/#WB16 if current.is(_RegionalIndicator) && lastExIgnore.is(_RegionalIndicator) { regionalIndicatorCount++ odd := regionalIndicatorCount%2 == 1 if odd { pos += w continue } } // https://unicode.org/reports/tr29/#WB999 // If we fall through all the above rules, it's a phrase break break } return pos, data[:pos], nil } golang-github-clipperhouse-uax29-2.7.0/phrases/string_test.go000066400000000000000000000271131515045622700242710ustar00rootroot00000000000000package phrases_test import ( "bytes" "strings" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/phrases" "github.com/clipperhouse/uax29/v2/testdata" ) func TestStringRoundtrip(t *testing.T) { t.Parallel() const runs = 100 tokens := phrases.FromString("") for i := 0; i < runs; i++ { input := string(getRandomBytes()) tokens.SetText(input) var output string for tokens.Next() { output += tokens.Value() } if output != input { t.Fatal("input bytes are not the same as output bytes") } } } func TestStringInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } tokens := phrases.FromBytes(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as output bytes") } } func stringIterToSetTrimmed(tokens *phrases.Iterator[string]) map[string]struct{} { founds := make(map[string]struct{}) for tokens.Next() { key := strings.TrimSpace(tokens.Value()) founds[key] = exists } return founds } func TestStringPhraseBoundaries(t *testing.T) { t.Parallel() input := []byte("This should break here. And then here. 世界. I think, perhaps you can understand that — aside 🏆 🐶 here — “a quote”.") tokens := phrases.FromString(string(input)) got := stringIterToSetTrimmed(tokens) expecteds := map[string]struct{}{ "This should break here": exists, "And then here": exists, "世": exists, // We don't have great logic for languages without spaces. Also true for words, see Notes: https://unicode.org/reports/tr29/#WB999 "I think": exists, "perhaps you can understand that": exists, "aside 🏆 🐶 here": exists, "a quote": exists, } for phrase := range expecteds { _, found := got[phrase] if !found { t.Fatalf("phrase %q was expected, not found", phrase) } } } // TestASCIIOptimization tests edge cases where the ASCII hot path in the iterator // could potentially produce incorrect results if not implemented correctly. func TestASCIIOptimization(t *testing.T) { t.Parallel() tests := []struct { name string input string expect []string // expected phrases (exact, not trimmed) }{ // All safe ASCII - should return as one phrase { name: "all safe ASCII", input: "hello world", expect: []string{"hello world"}, }, // Safe ASCII followed by breaking punctuation { name: "comma breaks phrase", input: "hello,world", expect: []string{"hello", ",", "world"}, }, // Non-safe char at start - no ASCII skip { name: "punctuation at start", input: "!hello", expect: []string{"!", "hello"}, }, // Safe ASCII followed by non-ASCII - space doesn't join with CJK { name: "ASCII then CJK", input: "hello 日本", expect: []string{"hello ", "日", "本"}, // CJK chars break from each other (no spaces) }, // Newline is NOT in safe set, should break { name: "newline breaks", input: "hello\nworld", expect: []string{"hello", "\n", "world"}, }, // Tab is NOT in safe set (only space ' ' is safe) { name: "tab breaks", input: "hello\tworld", expect: []string{"hello", "\t", "world"}, }, // Period breaks phrases { name: "period breaks", input: "hello. world", expect: []string{"hello", ".", " world"}, }, // Numbers are safe { name: "numbers are safe", input: "abc123 def456", expect: []string{"abc123 def456"}, }, // Empty string { name: "empty string", input: "", expect: []string{}, }, // Single safe char { name: "single safe char", input: "a", expect: []string{"a"}, }, // Single non-safe char { name: "single non-safe char", input: "!", expect: []string{"!"}, }, // Trailing space { name: "trailing space", input: "hello ", expect: []string{"hello "}, }, // Leading space { name: "leading space", input: " hello", expect: []string{" hello"}, }, // Only spaces { name: "only spaces", input: " ", expect: []string{" "}, }, // ASCII then emoji (emoji should continue phrase in phrases package) { name: "ASCII then emoji", input: "hello 🎉", expect: []string{"hello 🎉"}, }, // Multiple punctuation - period is MidNumLet so it joins letters (WB6/WB7) { name: "multiple punctuation", input: "a.b,c!d", expect: []string{"a.b", ",", "c", "!", "d"}, }, // Apostrophe in word (contraction) - apostrophe is SingleQuote, part of MidNumLetQ // WB6/WB7: don't break when MidNumLetQ is between letters { name: "apostrophe contraction don't", input: "don't stop", expect: []string{"don't stop"}, }, { name: "apostrophe contraction let's", input: "let's go", expect: []string{"let's go"}, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tokens := phrases.FromString(tt.input) var got []string for tokens.Next() { got = append(got, tokens.Value()) } if len(got) != len(tt.expect) { t.Errorf("got %d phrases %q, expected %d phrases %q", len(got), got, len(tt.expect), tt.expect) return } for i := range got { if got[i] != tt.expect[i] { t.Errorf("phrase %d: got %q, expected %q", i, got[i], tt.expect[i]) } } }) } } func TestFirstASCIIOptimization(t *testing.T) { t.Parallel() tests := []struct { name string input string expected string }{ // Pure ASCII hot path - all data consumed { name: "all ASCII alphanumeric", input: "hello world", expected: "hello world", }, { name: "all ASCII with numbers", input: "abc123 def456", expected: "abc123 def456", }, { name: "trailing space", input: "hello ", expected: "hello ", }, { name: "leading space", input: " hello", expected: " hello", }, { name: "only spaces", input: " ", expected: " ", }, // ASCII then non-ASCII triggers back-up + splitFunc { name: "ASCII then emoji continues", input: "hello 🎉 world", expected: "hello 🎉 world", }, { name: "ASCII then accented continues", input: "hello café", expected: "hello café", }, { name: "ASCII then CJK breaks", input: "hello 日本", expected: "hello ", }, // Punctuation triggers back-up + splitFunc { name: "comma breaks phrase", input: "hello, world", expected: "hello", }, { name: "period breaks phrase", input: "hello. world", expected: "hello", }, { name: "exclamation breaks phrase", input: "hello! world", expected: "hello", }, { name: "newline breaks phrase", input: "hello\nworld", expected: "hello", }, { name: "tab breaks phrase", input: "hello\tworld", expected: "hello", }, // Single character edge cases { name: "single ASCII letter", input: "a", expected: "a", }, { name: "single space", input: " ", expected: " ", }, { name: "single punctuation", input: "!", expected: "!", }, // Non-ASCII at start (no hot path) { name: "starts with non-ASCII", input: "éclair is tasty", expected: "éclair is tasty", }, { name: "starts with emoji", input: "🎉 party time", expected: "🎉 party time", }, { name: "starts with punctuation", input: "!hello world", expected: "!", }, // Back-up logic edge cases { name: "one char before break", input: "a,b", expected: "a", }, { name: "two chars before break", input: "ab,cd", expected: "ab", }, // Contraction handling { name: "apostrophe in word", input: "don't stop", expected: "don't stop", }, } for _, tt := range tests { t.Run(tt.name+"/string", func(t *testing.T) { iter := phrases.FromString(tt.input) got := iter.First() if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) t.Run(tt.name+"/bytes", func(t *testing.T) { iter := phrases.FromBytes([]byte(tt.input)) got := string(iter.First()) if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) } } func TestFirst(t *testing.T) { t.Parallel() tests := []struct { name string input string expected string }{ { name: "ASCII phrase", input: "hello world", expected: "hello world", }, { name: "ASCII phrase with comma", input: "hello, world", expected: "hello", }, { name: "Unicode phrase", input: "héllo world", expected: "héllo world", }, { name: "empty string", input: "", expected: "", }, { name: "single word", input: "hello", expected: "hello", }, { name: "pure ASCII alphanumeric with spaces", input: "abc123 def456", expected: "abc123 def456", }, { name: "starts with punctuation", input: "!hello", expected: "!", }, { name: "period breaks phrase", input: "hello. world", expected: "hello", }, { name: "contraction stays together", input: "don't stop", expected: "don't stop", }, { name: "ASCII then emoji", input: "hello 🎉", expected: "hello 🎉", }, { name: "newline breaks phrase", input: "hello\nworld", expected: "hello", }, } for _, tt := range tests { t.Run(tt.name+"/string", func(t *testing.T) { iter := phrases.FromString(tt.input) got := iter.First() if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) t.Run(tt.name+"/bytes", func(t *testing.T) { iter := phrases.FromBytes([]byte(tt.input)) got := string(iter.First()) if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) } } func BenchmarkStringMultilingual(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } s := string(file) len := len(file) b.SetBytes(int64(len)) b.ResetTimer() c := 0 for i := 0; i < b.N; i++ { tokens := phrases.FromString(s) for tokens.Next() { _ = tokens.Value() c++ } } } // BenchmarkStringASCII benchmarks realistic ASCII text with sentences and punctuation, // to measure the impact of the ASCII hot path optimization. func BenchmarkStringASCII(b *testing.B) { // Realistic English text with varied sentence structure and punctuation paragraph := `The quick brown fox jumps over the lazy dog. This sentence contains every letter of the alphabet! How fascinating is that? Well, it's been used for typing practice since the late 1800s. The phrase is simple, memorable, and effective. Teachers love it; students know it well. "Perfect for testing," they say. Numbers like 123 and 456 work too. Don't forget contractions: we'll, they're, and isn't. What about em-dashes—like this one? Or semicolons; they're useful too.` // Repeat to get a reasonable size var builder strings.Builder for i := 0; i < 100; i++ { builder.WriteString(paragraph) builder.WriteString(" ") } s := builder.String() length := len(s) b.SetBytes(int64(length)) b.ResetTimer() c := 0 for i := 0; i < b.N; i++ { tokens := phrases.FromString(s) for tokens.Next() { _ = tokens.Value() c++ } } } golang-github-clipperhouse-uax29-2.7.0/phrases/trie.go000066400000000000000000007666641515045622700227140ustar00rootroot00000000000000package phrases // generated by github.com/clipperhouse/uax29/v2 // from https://www.unicode.org/Public/17.0.0/ucd/auxiliary/WordBreakProperty.txt type property uint32 const ( _ALetter property = 1 << iota _CR _DoubleQuote _Extend _ExtendNumLet _ExtendedPictographic _Format _HebrewLetter _Katakana _LF _MidLetter _MidNum _MidNumLet _Newline _Numeric _RegionalIndicator _SingleQuote _WSegSpace _ZWJ ) // 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 lookup[T ~string | ~[]byte](s T) (v property, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return phrasesValues[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := phrasesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := phrasesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = phrasesIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := phrasesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = phrasesIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = phrasesIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // phrasesTrie. Total size: 95616 bytes (93.38 KiB). Checksum: 71d55844642e4474. // type phrasesTrie struct { } // func newPhrasesTrie(i int) *phrasesTrie { // return &phrasesTrie{} // } // lookupValue determines the type of block n and looks up the value for b. func lookupValue(n uint32, b byte) property { switch { default: return property(phrasesValues[n<<6+uint32(b)]) } } // phrasesValues: 360 blocks, 23040 entries, 92160 bytes // The third block is the zero block. var phrasesValues = [23040]property{ // Block 0x0, offset 0x0 0x0a: 0x0200, 0x0b: 0x2000, 0x0c: 0x2000, 0x0d: 0x0002, 0x20: 0x20000, 0x22: 0x0004, 0x27: 0x10000, 0x2c: 0x0800, 0x2e: 0x1000, 0x30: 0x4000, 0x31: 0x4000, 0x32: 0x4000, 0x33: 0x4000, 0x34: 0x4000, 0x35: 0x4000, 0x36: 0x4000, 0x37: 0x4000, 0x38: 0x4000, 0x39: 0x4000, 0x3a: 0x0400, 0x3b: 0x0800, // Block 0x1, offset 0x40 0x41: 0x0001, 0x42: 0x0001, 0x43: 0x0001, 0x44: 0x0001, 0x45: 0x0001, 0x46: 0x0001, 0x47: 0x0001, 0x48: 0x0001, 0x49: 0x0001, 0x4a: 0x0001, 0x4b: 0x0001, 0x4c: 0x0001, 0x4d: 0x0001, 0x4e: 0x0001, 0x4f: 0x0001, 0x50: 0x0001, 0x51: 0x0001, 0x52: 0x0001, 0x53: 0x0001, 0x54: 0x0001, 0x55: 0x0001, 0x56: 0x0001, 0x57: 0x0001, 0x58: 0x0001, 0x59: 0x0001, 0x5a: 0x0001, 0x5f: 0x0010, 0x61: 0x0001, 0x62: 0x0001, 0x63: 0x0001, 0x64: 0x0001, 0x65: 0x0001, 0x66: 0x0001, 0x67: 0x0001, 0x68: 0x0001, 0x69: 0x0001, 0x6a: 0x0001, 0x6b: 0x0001, 0x6c: 0x0001, 0x6d: 0x0001, 0x6e: 0x0001, 0x6f: 0x0001, 0x70: 0x0001, 0x71: 0x0001, 0x72: 0x0001, 0x73: 0x0001, 0x74: 0x0001, 0x75: 0x0001, 0x76: 0x0001, 0x77: 0x0001, 0x78: 0x0001, 0x79: 0x0001, 0x7a: 0x0001, // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc5: 0x2000, 0xe9: 0x0020, 0xea: 0x0001, 0xed: 0x0040, 0xee: 0x0020, 0xf5: 0x0001, 0xf7: 0x0400, 0xf8: 0x0001, 0xfa: 0x0001, // Block 0x4, offset 0x100 0x100: 0x0001, 0x101: 0x0001, 0x102: 0x0001, 0x103: 0x0001, 0x104: 0x0001, 0x105: 0x0001, 0x106: 0x0001, 0x107: 0x0001, 0x108: 0x0001, 0x109: 0x0001, 0x10a: 0x0001, 0x10b: 0x0001, 0x10c: 0x0001, 0x10d: 0x0001, 0x10e: 0x0001, 0x10f: 0x0001, 0x110: 0x0001, 0x111: 0x0001, 0x112: 0x0001, 0x113: 0x0001, 0x114: 0x0001, 0x115: 0x0001, 0x116: 0x0001, 0x118: 0x0001, 0x119: 0x0001, 0x11a: 0x0001, 0x11b: 0x0001, 0x11c: 0x0001, 0x11d: 0x0001, 0x11e: 0x0001, 0x11f: 0x0001, 0x120: 0x0001, 0x121: 0x0001, 0x122: 0x0001, 0x123: 0x0001, 0x124: 0x0001, 0x125: 0x0001, 0x126: 0x0001, 0x127: 0x0001, 0x128: 0x0001, 0x129: 0x0001, 0x12a: 0x0001, 0x12b: 0x0001, 0x12c: 0x0001, 0x12d: 0x0001, 0x12e: 0x0001, 0x12f: 0x0001, 0x130: 0x0001, 0x131: 0x0001, 0x132: 0x0001, 0x133: 0x0001, 0x134: 0x0001, 0x135: 0x0001, 0x136: 0x0001, 0x138: 0x0001, 0x139: 0x0001, 0x13a: 0x0001, 0x13b: 0x0001, 0x13c: 0x0001, 0x13d: 0x0001, 0x13e: 0x0001, 0x13f: 0x0001, // Block 0x5, offset 0x140 0x140: 0x0001, 0x141: 0x0001, 0x142: 0x0001, 0x143: 0x0001, 0x144: 0x0001, 0x145: 0x0001, 0x146: 0x0001, 0x147: 0x0001, 0x148: 0x0001, 0x149: 0x0001, 0x14a: 0x0001, 0x14b: 0x0001, 0x14c: 0x0001, 0x14d: 0x0001, 0x14e: 0x0001, 0x14f: 0x0001, 0x150: 0x0001, 0x151: 0x0001, 0x152: 0x0001, 0x153: 0x0001, 0x154: 0x0001, 0x155: 0x0001, 0x156: 0x0001, 0x157: 0x0001, 0x158: 0x0001, 0x159: 0x0001, 0x15a: 0x0001, 0x15b: 0x0001, 0x15c: 0x0001, 0x15d: 0x0001, 0x15e: 0x0001, 0x15f: 0x0001, 0x160: 0x0001, 0x161: 0x0001, 0x162: 0x0001, 0x163: 0x0001, 0x164: 0x0001, 0x165: 0x0001, 0x166: 0x0001, 0x167: 0x0001, 0x168: 0x0001, 0x169: 0x0001, 0x16a: 0x0001, 0x16b: 0x0001, 0x16c: 0x0001, 0x16d: 0x0001, 0x16e: 0x0001, 0x16f: 0x0001, 0x170: 0x0001, 0x171: 0x0001, 0x172: 0x0001, 0x173: 0x0001, 0x174: 0x0001, 0x175: 0x0001, 0x176: 0x0001, 0x177: 0x0001, 0x178: 0x0001, 0x179: 0x0001, 0x17a: 0x0001, 0x17b: 0x0001, 0x17c: 0x0001, 0x17d: 0x0001, 0x17e: 0x0001, 0x17f: 0x0001, // Block 0x6, offset 0x180 0x180: 0x0001, 0x181: 0x0001, 0x182: 0x0001, 0x183: 0x0001, 0x184: 0x0001, 0x185: 0x0001, 0x186: 0x0001, 0x187: 0x0001, 0x188: 0x0001, 0x189: 0x0001, 0x18a: 0x0001, 0x18b: 0x0001, 0x18c: 0x0001, 0x18d: 0x0001, 0x18e: 0x0001, 0x18f: 0x0001, 0x190: 0x0001, 0x191: 0x0001, 0x192: 0x0001, 0x193: 0x0001, 0x194: 0x0001, 0x195: 0x0001, 0x196: 0x0001, 0x197: 0x0001, 0x19e: 0x0001, 0x19f: 0x0001, 0x1a0: 0x0001, 0x1a1: 0x0001, 0x1a2: 0x0001, 0x1a3: 0x0001, 0x1a4: 0x0001, 0x1a5: 0x0001, 0x1a6: 0x0001, 0x1a7: 0x0001, 0x1a8: 0x0001, 0x1a9: 0x0001, 0x1aa: 0x0001, 0x1ab: 0x0001, 0x1ac: 0x0001, 0x1ad: 0x0001, 0x1ae: 0x0001, 0x1af: 0x0001, 0x1b0: 0x0001, 0x1b1: 0x0001, 0x1b2: 0x0001, 0x1b3: 0x0001, 0x1b4: 0x0001, 0x1b5: 0x0001, 0x1b6: 0x0001, 0x1b7: 0x0001, 0x1b8: 0x0001, 0x1b9: 0x0001, 0x1ba: 0x0001, 0x1bb: 0x0001, 0x1bc: 0x0001, 0x1bd: 0x0001, 0x1be: 0x0001, 0x1bf: 0x0001, // Block 0x7, offset 0x1c0 0x1c0: 0x0008, 0x1c1: 0x0008, 0x1c2: 0x0008, 0x1c3: 0x0008, 0x1c4: 0x0008, 0x1c5: 0x0008, 0x1c6: 0x0008, 0x1c7: 0x0008, 0x1c8: 0x0008, 0x1c9: 0x0008, 0x1ca: 0x0008, 0x1cb: 0x0008, 0x1cc: 0x0008, 0x1cd: 0x0008, 0x1ce: 0x0008, 0x1cf: 0x0008, 0x1d0: 0x0008, 0x1d1: 0x0008, 0x1d2: 0x0008, 0x1d3: 0x0008, 0x1d4: 0x0008, 0x1d5: 0x0008, 0x1d6: 0x0008, 0x1d7: 0x0008, 0x1d8: 0x0008, 0x1d9: 0x0008, 0x1da: 0x0008, 0x1db: 0x0008, 0x1dc: 0x0008, 0x1dd: 0x0008, 0x1de: 0x0008, 0x1df: 0x0008, 0x1e0: 0x0008, 0x1e1: 0x0008, 0x1e2: 0x0008, 0x1e3: 0x0008, 0x1e4: 0x0008, 0x1e5: 0x0008, 0x1e6: 0x0008, 0x1e7: 0x0008, 0x1e8: 0x0008, 0x1e9: 0x0008, 0x1ea: 0x0008, 0x1eb: 0x0008, 0x1ec: 0x0008, 0x1ed: 0x0008, 0x1ee: 0x0008, 0x1ef: 0x0008, 0x1f0: 0x0008, 0x1f1: 0x0008, 0x1f2: 0x0008, 0x1f3: 0x0008, 0x1f4: 0x0008, 0x1f5: 0x0008, 0x1f6: 0x0008, 0x1f7: 0x0008, 0x1f8: 0x0008, 0x1f9: 0x0008, 0x1fa: 0x0008, 0x1fb: 0x0008, 0x1fc: 0x0008, 0x1fd: 0x0008, 0x1fe: 0x0008, 0x1ff: 0x0008, // Block 0x8, offset 0x200 0x200: 0x0008, 0x201: 0x0008, 0x202: 0x0008, 0x203: 0x0008, 0x204: 0x0008, 0x205: 0x0008, 0x206: 0x0008, 0x207: 0x0008, 0x208: 0x0008, 0x209: 0x0008, 0x20a: 0x0008, 0x20b: 0x0008, 0x20c: 0x0008, 0x20d: 0x0008, 0x20e: 0x0008, 0x20f: 0x0008, 0x210: 0x0008, 0x211: 0x0008, 0x212: 0x0008, 0x213: 0x0008, 0x214: 0x0008, 0x215: 0x0008, 0x216: 0x0008, 0x217: 0x0008, 0x218: 0x0008, 0x219: 0x0008, 0x21a: 0x0008, 0x21b: 0x0008, 0x21c: 0x0008, 0x21d: 0x0008, 0x21e: 0x0008, 0x21f: 0x0008, 0x220: 0x0008, 0x221: 0x0008, 0x222: 0x0008, 0x223: 0x0008, 0x224: 0x0008, 0x225: 0x0008, 0x226: 0x0008, 0x227: 0x0008, 0x228: 0x0008, 0x229: 0x0008, 0x22a: 0x0008, 0x22b: 0x0008, 0x22c: 0x0008, 0x22d: 0x0008, 0x22e: 0x0008, 0x22f: 0x0008, 0x230: 0x0001, 0x231: 0x0001, 0x232: 0x0001, 0x233: 0x0001, 0x234: 0x0001, 0x236: 0x0001, 0x237: 0x0001, 0x23a: 0x0001, 0x23b: 0x0001, 0x23c: 0x0001, 0x23d: 0x0001, 0x23e: 0x0800, 0x23f: 0x0001, // Block 0x9, offset 0x240 0x246: 0x0001, 0x247: 0x0400, 0x248: 0x0001, 0x249: 0x0001, 0x24a: 0x0001, 0x24c: 0x0001, 0x24e: 0x0001, 0x24f: 0x0001, 0x250: 0x0001, 0x251: 0x0001, 0x252: 0x0001, 0x253: 0x0001, 0x254: 0x0001, 0x255: 0x0001, 0x256: 0x0001, 0x257: 0x0001, 0x258: 0x0001, 0x259: 0x0001, 0x25a: 0x0001, 0x25b: 0x0001, 0x25c: 0x0001, 0x25d: 0x0001, 0x25e: 0x0001, 0x25f: 0x0001, 0x260: 0x0001, 0x261: 0x0001, 0x263: 0x0001, 0x264: 0x0001, 0x265: 0x0001, 0x266: 0x0001, 0x267: 0x0001, 0x268: 0x0001, 0x269: 0x0001, 0x26a: 0x0001, 0x26b: 0x0001, 0x26c: 0x0001, 0x26d: 0x0001, 0x26e: 0x0001, 0x26f: 0x0001, 0x270: 0x0001, 0x271: 0x0001, 0x272: 0x0001, 0x273: 0x0001, 0x274: 0x0001, 0x275: 0x0001, 0x276: 0x0001, 0x277: 0x0001, 0x278: 0x0001, 0x279: 0x0001, 0x27a: 0x0001, 0x27b: 0x0001, 0x27c: 0x0001, 0x27d: 0x0001, 0x27e: 0x0001, 0x27f: 0x0001, // Block 0xa, offset 0x280 0x280: 0x0001, 0x281: 0x0001, 0x282: 0x0001, 0x283: 0x0001, 0x284: 0x0001, 0x285: 0x0001, 0x286: 0x0001, 0x287: 0x0001, 0x288: 0x0001, 0x289: 0x0001, 0x28a: 0x0001, 0x28b: 0x0001, 0x28c: 0x0001, 0x28d: 0x0001, 0x28e: 0x0001, 0x28f: 0x0001, 0x290: 0x0001, 0x291: 0x0001, 0x292: 0x0001, 0x293: 0x0001, 0x294: 0x0001, 0x295: 0x0001, 0x296: 0x0001, 0x297: 0x0001, 0x298: 0x0001, 0x299: 0x0001, 0x29a: 0x0001, 0x29b: 0x0001, 0x29c: 0x0001, 0x29d: 0x0001, 0x29e: 0x0001, 0x29f: 0x0001, 0x2a0: 0x0001, 0x2a1: 0x0001, 0x2a2: 0x0001, 0x2a3: 0x0001, 0x2a4: 0x0001, 0x2a5: 0x0001, 0x2a6: 0x0001, 0x2a7: 0x0001, 0x2a8: 0x0001, 0x2a9: 0x0001, 0x2aa: 0x0001, 0x2ab: 0x0001, 0x2ac: 0x0001, 0x2ad: 0x0001, 0x2ae: 0x0001, 0x2af: 0x0001, 0x2b0: 0x0001, 0x2b1: 0x0001, 0x2b2: 0x0001, 0x2b3: 0x0001, 0x2b4: 0x0001, 0x2b5: 0x0001, 0x2b7: 0x0001, 0x2b8: 0x0001, 0x2b9: 0x0001, 0x2ba: 0x0001, 0x2bb: 0x0001, 0x2bc: 0x0001, 0x2bd: 0x0001, 0x2be: 0x0001, 0x2bf: 0x0001, // Block 0xb, offset 0x2c0 0x2c0: 0x0001, 0x2c1: 0x0001, 0x2c3: 0x0008, 0x2c4: 0x0008, 0x2c5: 0x0008, 0x2c6: 0x0008, 0x2c7: 0x0008, 0x2c8: 0x0008, 0x2c9: 0x0008, 0x2ca: 0x0001, 0x2cb: 0x0001, 0x2cc: 0x0001, 0x2cd: 0x0001, 0x2ce: 0x0001, 0x2cf: 0x0001, 0x2d0: 0x0001, 0x2d1: 0x0001, 0x2d2: 0x0001, 0x2d3: 0x0001, 0x2d4: 0x0001, 0x2d5: 0x0001, 0x2d6: 0x0001, 0x2d7: 0x0001, 0x2d8: 0x0001, 0x2d9: 0x0001, 0x2da: 0x0001, 0x2db: 0x0001, 0x2dc: 0x0001, 0x2dd: 0x0001, 0x2de: 0x0001, 0x2df: 0x0001, 0x2e0: 0x0001, 0x2e1: 0x0001, 0x2e2: 0x0001, 0x2e3: 0x0001, 0x2e4: 0x0001, 0x2e5: 0x0001, 0x2e6: 0x0001, 0x2e7: 0x0001, 0x2e8: 0x0001, 0x2e9: 0x0001, 0x2ea: 0x0001, 0x2eb: 0x0001, 0x2ec: 0x0001, 0x2ed: 0x0001, 0x2ee: 0x0001, 0x2ef: 0x0001, 0x2f0: 0x0001, 0x2f1: 0x0001, 0x2f2: 0x0001, 0x2f3: 0x0001, 0x2f4: 0x0001, 0x2f5: 0x0001, 0x2f6: 0x0001, 0x2f7: 0x0001, 0x2f8: 0x0001, 0x2f9: 0x0001, 0x2fa: 0x0001, 0x2fb: 0x0001, 0x2fc: 0x0001, 0x2fd: 0x0001, 0x2fe: 0x0001, 0x2ff: 0x0001, // Block 0xc, offset 0x300 0x300: 0x0001, 0x301: 0x0001, 0x302: 0x0001, 0x303: 0x0001, 0x304: 0x0001, 0x305: 0x0001, 0x306: 0x0001, 0x307: 0x0001, 0x308: 0x0001, 0x309: 0x0001, 0x30a: 0x0001, 0x30b: 0x0001, 0x30c: 0x0001, 0x30d: 0x0001, 0x30e: 0x0001, 0x30f: 0x0001, 0x310: 0x0001, 0x311: 0x0001, 0x312: 0x0001, 0x313: 0x0001, 0x314: 0x0001, 0x315: 0x0001, 0x316: 0x0001, 0x317: 0x0001, 0x318: 0x0001, 0x319: 0x0001, 0x31a: 0x0001, 0x31b: 0x0001, 0x31c: 0x0001, 0x31d: 0x0001, 0x31e: 0x0001, 0x31f: 0x0001, 0x320: 0x0001, 0x321: 0x0001, 0x322: 0x0001, 0x323: 0x0001, 0x324: 0x0001, 0x325: 0x0001, 0x326: 0x0001, 0x327: 0x0001, 0x328: 0x0001, 0x329: 0x0001, 0x32a: 0x0001, 0x32b: 0x0001, 0x32c: 0x0001, 0x32d: 0x0001, 0x32e: 0x0001, 0x32f: 0x0001, 0x331: 0x0001, 0x332: 0x0001, 0x333: 0x0001, 0x334: 0x0001, 0x335: 0x0001, 0x336: 0x0001, 0x337: 0x0001, 0x338: 0x0001, 0x339: 0x0001, 0x33a: 0x0001, 0x33b: 0x0001, 0x33c: 0x0001, 0x33d: 0x0001, 0x33e: 0x0001, 0x33f: 0x0001, // Block 0xd, offset 0x340 0x340: 0x0001, 0x341: 0x0001, 0x342: 0x0001, 0x343: 0x0001, 0x344: 0x0001, 0x345: 0x0001, 0x346: 0x0001, 0x347: 0x0001, 0x348: 0x0001, 0x349: 0x0001, 0x34a: 0x0001, 0x34b: 0x0001, 0x34c: 0x0001, 0x34d: 0x0001, 0x34e: 0x0001, 0x34f: 0x0001, 0x350: 0x0001, 0x351: 0x0001, 0x352: 0x0001, 0x353: 0x0001, 0x354: 0x0001, 0x355: 0x0001, 0x356: 0x0001, 0x359: 0x0001, 0x35a: 0x0001, 0x35b: 0x0001, 0x35c: 0x0001, 0x35e: 0x0001, 0x35f: 0x0400, 0x360: 0x0001, 0x361: 0x0001, 0x362: 0x0001, 0x363: 0x0001, 0x364: 0x0001, 0x365: 0x0001, 0x366: 0x0001, 0x367: 0x0001, 0x368: 0x0001, 0x369: 0x0001, 0x36a: 0x0001, 0x36b: 0x0001, 0x36c: 0x0001, 0x36d: 0x0001, 0x36e: 0x0001, 0x36f: 0x0001, 0x370: 0x0001, 0x371: 0x0001, 0x372: 0x0001, 0x373: 0x0001, 0x374: 0x0001, 0x375: 0x0001, 0x376: 0x0001, 0x377: 0x0001, 0x378: 0x0001, 0x379: 0x0001, 0x37a: 0x0001, 0x37b: 0x0001, 0x37c: 0x0001, 0x37d: 0x0001, 0x37e: 0x0001, 0x37f: 0x0001, // Block 0xe, offset 0x380 0x380: 0x0001, 0x381: 0x0001, 0x382: 0x0001, 0x383: 0x0001, 0x384: 0x0001, 0x385: 0x0001, 0x386: 0x0001, 0x387: 0x0001, 0x388: 0x0001, 0x389: 0x0800, 0x38a: 0x0001, 0x391: 0x0008, 0x392: 0x0008, 0x393: 0x0008, 0x394: 0x0008, 0x395: 0x0008, 0x396: 0x0008, 0x397: 0x0008, 0x398: 0x0008, 0x399: 0x0008, 0x39a: 0x0008, 0x39b: 0x0008, 0x39c: 0x0008, 0x39d: 0x0008, 0x39e: 0x0008, 0x39f: 0x0008, 0x3a0: 0x0008, 0x3a1: 0x0008, 0x3a2: 0x0008, 0x3a3: 0x0008, 0x3a4: 0x0008, 0x3a5: 0x0008, 0x3a6: 0x0008, 0x3a7: 0x0008, 0x3a8: 0x0008, 0x3a9: 0x0008, 0x3aa: 0x0008, 0x3ab: 0x0008, 0x3ac: 0x0008, 0x3ad: 0x0008, 0x3ae: 0x0008, 0x3af: 0x0008, 0x3b0: 0x0008, 0x3b1: 0x0008, 0x3b2: 0x0008, 0x3b3: 0x0008, 0x3b4: 0x0008, 0x3b5: 0x0008, 0x3b6: 0x0008, 0x3b7: 0x0008, 0x3b8: 0x0008, 0x3b9: 0x0008, 0x3ba: 0x0008, 0x3bb: 0x0008, 0x3bc: 0x0008, 0x3bd: 0x0008, 0x3bf: 0x0008, // Block 0xf, offset 0x3c0 0x3c1: 0x0008, 0x3c2: 0x0008, 0x3c4: 0x0008, 0x3c5: 0x0008, 0x3c7: 0x0008, 0x3d0: 0x0080, 0x3d1: 0x0080, 0x3d2: 0x0080, 0x3d3: 0x0080, 0x3d4: 0x0080, 0x3d5: 0x0080, 0x3d6: 0x0080, 0x3d7: 0x0080, 0x3d8: 0x0080, 0x3d9: 0x0080, 0x3da: 0x0080, 0x3db: 0x0080, 0x3dc: 0x0080, 0x3dd: 0x0080, 0x3de: 0x0080, 0x3df: 0x0080, 0x3e0: 0x0080, 0x3e1: 0x0080, 0x3e2: 0x0080, 0x3e3: 0x0080, 0x3e4: 0x0080, 0x3e5: 0x0080, 0x3e6: 0x0080, 0x3e7: 0x0080, 0x3e8: 0x0080, 0x3e9: 0x0080, 0x3ea: 0x0080, 0x3ef: 0x0080, 0x3f0: 0x0080, 0x3f1: 0x0080, 0x3f2: 0x0080, 0x3f3: 0x0001, 0x3f4: 0x0400, // Block 0x10, offset 0x400 0x400: 0x4000, 0x401: 0x4000, 0x402: 0x4000, 0x403: 0x4000, 0x404: 0x4000, 0x405: 0x4000, 0x40c: 0x0800, 0x40d: 0x0800, 0x410: 0x0008, 0x411: 0x0008, 0x412: 0x0008, 0x413: 0x0008, 0x414: 0x0008, 0x415: 0x0008, 0x416: 0x0008, 0x417: 0x0008, 0x418: 0x0008, 0x419: 0x0008, 0x41a: 0x0008, 0x41c: 0x0040, 0x420: 0x0001, 0x421: 0x0001, 0x422: 0x0001, 0x423: 0x0001, 0x424: 0x0001, 0x425: 0x0001, 0x426: 0x0001, 0x427: 0x0001, 0x428: 0x0001, 0x429: 0x0001, 0x42a: 0x0001, 0x42b: 0x0001, 0x42c: 0x0001, 0x42d: 0x0001, 0x42e: 0x0001, 0x42f: 0x0001, 0x430: 0x0001, 0x431: 0x0001, 0x432: 0x0001, 0x433: 0x0001, 0x434: 0x0001, 0x435: 0x0001, 0x436: 0x0001, 0x437: 0x0001, 0x438: 0x0001, 0x439: 0x0001, 0x43a: 0x0001, 0x43b: 0x0001, 0x43c: 0x0001, 0x43d: 0x0001, 0x43e: 0x0001, 0x43f: 0x0001, // Block 0x11, offset 0x440 0x440: 0x0001, 0x441: 0x0001, 0x442: 0x0001, 0x443: 0x0001, 0x444: 0x0001, 0x445: 0x0001, 0x446: 0x0001, 0x447: 0x0001, 0x448: 0x0001, 0x449: 0x0001, 0x44a: 0x0001, 0x44b: 0x0008, 0x44c: 0x0008, 0x44d: 0x0008, 0x44e: 0x0008, 0x44f: 0x0008, 0x450: 0x0008, 0x451: 0x0008, 0x452: 0x0008, 0x453: 0x0008, 0x454: 0x0008, 0x455: 0x0008, 0x456: 0x0008, 0x457: 0x0008, 0x458: 0x0008, 0x459: 0x0008, 0x45a: 0x0008, 0x45b: 0x0008, 0x45c: 0x0008, 0x45d: 0x0008, 0x45e: 0x0008, 0x45f: 0x0008, 0x460: 0x4000, 0x461: 0x4000, 0x462: 0x4000, 0x463: 0x4000, 0x464: 0x4000, 0x465: 0x4000, 0x466: 0x4000, 0x467: 0x4000, 0x468: 0x4000, 0x469: 0x4000, 0x46b: 0x4000, 0x46c: 0x0800, 0x46e: 0x0001, 0x46f: 0x0001, 0x470: 0x0008, 0x471: 0x0001, 0x472: 0x0001, 0x473: 0x0001, 0x474: 0x0001, 0x475: 0x0001, 0x476: 0x0001, 0x477: 0x0001, 0x478: 0x0001, 0x479: 0x0001, 0x47a: 0x0001, 0x47b: 0x0001, 0x47c: 0x0001, 0x47d: 0x0001, 0x47e: 0x0001, 0x47f: 0x0001, // Block 0x12, offset 0x480 0x480: 0x0001, 0x481: 0x0001, 0x482: 0x0001, 0x483: 0x0001, 0x484: 0x0001, 0x485: 0x0001, 0x486: 0x0001, 0x487: 0x0001, 0x488: 0x0001, 0x489: 0x0001, 0x48a: 0x0001, 0x48b: 0x0001, 0x48c: 0x0001, 0x48d: 0x0001, 0x48e: 0x0001, 0x48f: 0x0001, 0x490: 0x0001, 0x491: 0x0001, 0x492: 0x0001, 0x493: 0x0001, 0x495: 0x0001, 0x496: 0x0008, 0x497: 0x0008, 0x498: 0x0008, 0x499: 0x0008, 0x49a: 0x0008, 0x49b: 0x0008, 0x49c: 0x0008, 0x49d: 0x4000, 0x49f: 0x0008, 0x4a0: 0x0008, 0x4a1: 0x0008, 0x4a2: 0x0008, 0x4a3: 0x0008, 0x4a4: 0x0008, 0x4a5: 0x0001, 0x4a6: 0x0001, 0x4a7: 0x0008, 0x4a8: 0x0008, 0x4aa: 0x0008, 0x4ab: 0x0008, 0x4ac: 0x0008, 0x4ad: 0x0008, 0x4ae: 0x0001, 0x4af: 0x0001, 0x4b0: 0x4000, 0x4b1: 0x4000, 0x4b2: 0x4000, 0x4b3: 0x4000, 0x4b4: 0x4000, 0x4b5: 0x4000, 0x4b6: 0x4000, 0x4b7: 0x4000, 0x4b8: 0x4000, 0x4b9: 0x4000, 0x4ba: 0x0001, 0x4bb: 0x0001, 0x4bc: 0x0001, 0x4bf: 0x0001, // Block 0x13, offset 0x4c0 0x4cf: 0x0001, 0x4d0: 0x0001, 0x4d1: 0x0008, 0x4d2: 0x0001, 0x4d3: 0x0001, 0x4d4: 0x0001, 0x4d5: 0x0001, 0x4d6: 0x0001, 0x4d7: 0x0001, 0x4d8: 0x0001, 0x4d9: 0x0001, 0x4da: 0x0001, 0x4db: 0x0001, 0x4dc: 0x0001, 0x4dd: 0x0001, 0x4de: 0x0001, 0x4df: 0x0001, 0x4e0: 0x0001, 0x4e1: 0x0001, 0x4e2: 0x0001, 0x4e3: 0x0001, 0x4e4: 0x0001, 0x4e5: 0x0001, 0x4e6: 0x0001, 0x4e7: 0x0001, 0x4e8: 0x0001, 0x4e9: 0x0001, 0x4ea: 0x0001, 0x4eb: 0x0001, 0x4ec: 0x0001, 0x4ed: 0x0001, 0x4ee: 0x0001, 0x4ef: 0x0001, 0x4f0: 0x0008, 0x4f1: 0x0008, 0x4f2: 0x0008, 0x4f3: 0x0008, 0x4f4: 0x0008, 0x4f5: 0x0008, 0x4f6: 0x0008, 0x4f7: 0x0008, 0x4f8: 0x0008, 0x4f9: 0x0008, 0x4fa: 0x0008, 0x4fb: 0x0008, 0x4fc: 0x0008, 0x4fd: 0x0008, 0x4fe: 0x0008, 0x4ff: 0x0008, // Block 0x14, offset 0x500 0x500: 0x0008, 0x501: 0x0008, 0x502: 0x0008, 0x503: 0x0008, 0x504: 0x0008, 0x505: 0x0008, 0x506: 0x0008, 0x507: 0x0008, 0x508: 0x0008, 0x509: 0x0008, 0x50a: 0x0008, 0x50d: 0x0001, 0x50e: 0x0001, 0x50f: 0x0001, 0x510: 0x0001, 0x511: 0x0001, 0x512: 0x0001, 0x513: 0x0001, 0x514: 0x0001, 0x515: 0x0001, 0x516: 0x0001, 0x517: 0x0001, 0x518: 0x0001, 0x519: 0x0001, 0x51a: 0x0001, 0x51b: 0x0001, 0x51c: 0x0001, 0x51d: 0x0001, 0x51e: 0x0001, 0x51f: 0x0001, 0x520: 0x0001, 0x521: 0x0001, 0x522: 0x0001, 0x523: 0x0001, 0x524: 0x0001, 0x525: 0x0001, 0x526: 0x0001, 0x527: 0x0001, 0x528: 0x0001, 0x529: 0x0001, 0x52a: 0x0001, 0x52b: 0x0001, 0x52c: 0x0001, 0x52d: 0x0001, 0x52e: 0x0001, 0x52f: 0x0001, 0x530: 0x0001, 0x531: 0x0001, 0x532: 0x0001, 0x533: 0x0001, 0x534: 0x0001, 0x535: 0x0001, 0x536: 0x0001, 0x537: 0x0001, 0x538: 0x0001, 0x539: 0x0001, 0x53a: 0x0001, 0x53b: 0x0001, 0x53c: 0x0001, 0x53d: 0x0001, 0x53e: 0x0001, 0x53f: 0x0001, // Block 0x15, offset 0x540 0x540: 0x0001, 0x541: 0x0001, 0x542: 0x0001, 0x543: 0x0001, 0x544: 0x0001, 0x545: 0x0001, 0x546: 0x0001, 0x547: 0x0001, 0x548: 0x0001, 0x549: 0x0001, 0x54a: 0x0001, 0x54b: 0x0001, 0x54c: 0x0001, 0x54d: 0x0001, 0x54e: 0x0001, 0x54f: 0x0001, 0x550: 0x0001, 0x551: 0x0001, 0x552: 0x0001, 0x553: 0x0001, 0x554: 0x0001, 0x555: 0x0001, 0x556: 0x0001, 0x557: 0x0001, 0x558: 0x0001, 0x559: 0x0001, 0x55a: 0x0001, 0x55b: 0x0001, 0x55c: 0x0001, 0x55d: 0x0001, 0x55e: 0x0001, 0x55f: 0x0001, 0x560: 0x0001, 0x561: 0x0001, 0x562: 0x0001, 0x563: 0x0001, 0x564: 0x0001, 0x565: 0x0001, 0x566: 0x0008, 0x567: 0x0008, 0x568: 0x0008, 0x569: 0x0008, 0x56a: 0x0008, 0x56b: 0x0008, 0x56c: 0x0008, 0x56d: 0x0008, 0x56e: 0x0008, 0x56f: 0x0008, 0x570: 0x0008, 0x571: 0x0001, // Block 0x16, offset 0x580 0x580: 0x4000, 0x581: 0x4000, 0x582: 0x4000, 0x583: 0x4000, 0x584: 0x4000, 0x585: 0x4000, 0x586: 0x4000, 0x587: 0x4000, 0x588: 0x4000, 0x589: 0x4000, 0x58a: 0x0001, 0x58b: 0x0001, 0x58c: 0x0001, 0x58d: 0x0001, 0x58e: 0x0001, 0x58f: 0x0001, 0x590: 0x0001, 0x591: 0x0001, 0x592: 0x0001, 0x593: 0x0001, 0x594: 0x0001, 0x595: 0x0001, 0x596: 0x0001, 0x597: 0x0001, 0x598: 0x0001, 0x599: 0x0001, 0x59a: 0x0001, 0x59b: 0x0001, 0x59c: 0x0001, 0x59d: 0x0001, 0x59e: 0x0001, 0x59f: 0x0001, 0x5a0: 0x0001, 0x5a1: 0x0001, 0x5a2: 0x0001, 0x5a3: 0x0001, 0x5a4: 0x0001, 0x5a5: 0x0001, 0x5a6: 0x0001, 0x5a7: 0x0001, 0x5a8: 0x0001, 0x5a9: 0x0001, 0x5aa: 0x0001, 0x5ab: 0x0008, 0x5ac: 0x0008, 0x5ad: 0x0008, 0x5ae: 0x0008, 0x5af: 0x0008, 0x5b0: 0x0008, 0x5b1: 0x0008, 0x5b2: 0x0008, 0x5b3: 0x0008, 0x5b4: 0x0001, 0x5b5: 0x0001, 0x5b8: 0x0800, 0x5ba: 0x0001, 0x5bd: 0x0008, // Block 0x17, offset 0x5c0 0x5c0: 0x0001, 0x5c1: 0x0001, 0x5c2: 0x0001, 0x5c3: 0x0001, 0x5c4: 0x0001, 0x5c5: 0x0001, 0x5c6: 0x0001, 0x5c7: 0x0001, 0x5c8: 0x0001, 0x5c9: 0x0001, 0x5ca: 0x0001, 0x5cb: 0x0001, 0x5cc: 0x0001, 0x5cd: 0x0001, 0x5ce: 0x0001, 0x5cf: 0x0001, 0x5d0: 0x0001, 0x5d1: 0x0001, 0x5d2: 0x0001, 0x5d3: 0x0001, 0x5d4: 0x0001, 0x5d5: 0x0001, 0x5d6: 0x0008, 0x5d7: 0x0008, 0x5d8: 0x0008, 0x5d9: 0x0008, 0x5da: 0x0001, 0x5db: 0x0008, 0x5dc: 0x0008, 0x5dd: 0x0008, 0x5de: 0x0008, 0x5df: 0x0008, 0x5e0: 0x0008, 0x5e1: 0x0008, 0x5e2: 0x0008, 0x5e3: 0x0008, 0x5e4: 0x0001, 0x5e5: 0x0008, 0x5e6: 0x0008, 0x5e7: 0x0008, 0x5e8: 0x0001, 0x5e9: 0x0008, 0x5ea: 0x0008, 0x5eb: 0x0008, 0x5ec: 0x0008, 0x5ed: 0x0008, // Block 0x18, offset 0x600 0x600: 0x0001, 0x601: 0x0001, 0x602: 0x0001, 0x603: 0x0001, 0x604: 0x0001, 0x605: 0x0001, 0x606: 0x0001, 0x607: 0x0001, 0x608: 0x0001, 0x609: 0x0001, 0x60a: 0x0001, 0x60b: 0x0001, 0x60c: 0x0001, 0x60d: 0x0001, 0x60e: 0x0001, 0x60f: 0x0001, 0x610: 0x0001, 0x611: 0x0001, 0x612: 0x0001, 0x613: 0x0001, 0x614: 0x0001, 0x615: 0x0001, 0x616: 0x0001, 0x617: 0x0001, 0x618: 0x0001, 0x619: 0x0008, 0x61a: 0x0008, 0x61b: 0x0008, 0x620: 0x0001, 0x621: 0x0001, 0x622: 0x0001, 0x623: 0x0001, 0x624: 0x0001, 0x625: 0x0001, 0x626: 0x0001, 0x627: 0x0001, 0x628: 0x0001, 0x629: 0x0001, 0x62a: 0x0001, 0x630: 0x0001, 0x631: 0x0001, 0x632: 0x0001, 0x633: 0x0001, 0x634: 0x0001, 0x635: 0x0001, 0x636: 0x0001, 0x637: 0x0001, 0x638: 0x0001, 0x639: 0x0001, 0x63a: 0x0001, 0x63b: 0x0001, 0x63c: 0x0001, 0x63d: 0x0001, 0x63e: 0x0001, 0x63f: 0x0001, // Block 0x19, offset 0x640 0x640: 0x0001, 0x641: 0x0001, 0x642: 0x0001, 0x643: 0x0001, 0x644: 0x0001, 0x645: 0x0001, 0x646: 0x0001, 0x647: 0x0001, 0x649: 0x0001, 0x64a: 0x0001, 0x64b: 0x0001, 0x64c: 0x0001, 0x64d: 0x0001, 0x64e: 0x0001, 0x64f: 0x0001, 0x650: 0x4000, 0x651: 0x4000, 0x657: 0x0008, 0x658: 0x0008, 0x659: 0x0008, 0x65a: 0x0008, 0x65b: 0x0008, 0x65c: 0x0008, 0x65d: 0x0008, 0x65e: 0x0008, 0x65f: 0x0008, 0x660: 0x0001, 0x661: 0x0001, 0x662: 0x0001, 0x663: 0x0001, 0x664: 0x0001, 0x665: 0x0001, 0x666: 0x0001, 0x667: 0x0001, 0x668: 0x0001, 0x669: 0x0001, 0x66a: 0x0001, 0x66b: 0x0001, 0x66c: 0x0001, 0x66d: 0x0001, 0x66e: 0x0001, 0x66f: 0x0001, 0x670: 0x0001, 0x671: 0x0001, 0x672: 0x0001, 0x673: 0x0001, 0x674: 0x0001, 0x675: 0x0001, 0x676: 0x0001, 0x677: 0x0001, 0x678: 0x0001, 0x679: 0x0001, 0x67a: 0x0001, 0x67b: 0x0001, 0x67c: 0x0001, 0x67d: 0x0001, 0x67e: 0x0001, 0x67f: 0x0001, // Block 0x1a, offset 0x680 0x680: 0x0001, 0x681: 0x0001, 0x682: 0x0001, 0x683: 0x0001, 0x684: 0x0001, 0x685: 0x0001, 0x686: 0x0001, 0x687: 0x0001, 0x688: 0x0001, 0x689: 0x0001, 0x68a: 0x0008, 0x68b: 0x0008, 0x68c: 0x0008, 0x68d: 0x0008, 0x68e: 0x0008, 0x68f: 0x0008, 0x690: 0x0008, 0x691: 0x0008, 0x692: 0x0008, 0x693: 0x0008, 0x694: 0x0008, 0x695: 0x0008, 0x696: 0x0008, 0x697: 0x0008, 0x698: 0x0008, 0x699: 0x0008, 0x69a: 0x0008, 0x69b: 0x0008, 0x69c: 0x0008, 0x69d: 0x0008, 0x69e: 0x0008, 0x69f: 0x0008, 0x6a0: 0x0008, 0x6a1: 0x0008, 0x6a2: 0x4000, 0x6a3: 0x0008, 0x6a4: 0x0008, 0x6a5: 0x0008, 0x6a6: 0x0008, 0x6a7: 0x0008, 0x6a8: 0x0008, 0x6a9: 0x0008, 0x6aa: 0x0008, 0x6ab: 0x0008, 0x6ac: 0x0008, 0x6ad: 0x0008, 0x6ae: 0x0008, 0x6af: 0x0008, 0x6b0: 0x0008, 0x6b1: 0x0008, 0x6b2: 0x0008, 0x6b3: 0x0008, 0x6b4: 0x0008, 0x6b5: 0x0008, 0x6b6: 0x0008, 0x6b7: 0x0008, 0x6b8: 0x0008, 0x6b9: 0x0008, 0x6ba: 0x0008, 0x6bb: 0x0008, 0x6bc: 0x0008, 0x6bd: 0x0008, 0x6be: 0x0008, 0x6bf: 0x0008, // Block 0x1b, offset 0x6c0 0x6c0: 0x0008, 0x6c1: 0x0008, 0x6c2: 0x0008, 0x6c3: 0x0008, 0x6c4: 0x0001, 0x6c5: 0x0001, 0x6c6: 0x0001, 0x6c7: 0x0001, 0x6c8: 0x0001, 0x6c9: 0x0001, 0x6ca: 0x0001, 0x6cb: 0x0001, 0x6cc: 0x0001, 0x6cd: 0x0001, 0x6ce: 0x0001, 0x6cf: 0x0001, 0x6d0: 0x0001, 0x6d1: 0x0001, 0x6d2: 0x0001, 0x6d3: 0x0001, 0x6d4: 0x0001, 0x6d5: 0x0001, 0x6d6: 0x0001, 0x6d7: 0x0001, 0x6d8: 0x0001, 0x6d9: 0x0001, 0x6da: 0x0001, 0x6db: 0x0001, 0x6dc: 0x0001, 0x6dd: 0x0001, 0x6de: 0x0001, 0x6df: 0x0001, 0x6e0: 0x0001, 0x6e1: 0x0001, 0x6e2: 0x0001, 0x6e3: 0x0001, 0x6e4: 0x0001, 0x6e5: 0x0001, 0x6e6: 0x0001, 0x6e7: 0x0001, 0x6e8: 0x0001, 0x6e9: 0x0001, 0x6ea: 0x0001, 0x6eb: 0x0001, 0x6ec: 0x0001, 0x6ed: 0x0001, 0x6ee: 0x0001, 0x6ef: 0x0001, 0x6f0: 0x0001, 0x6f1: 0x0001, 0x6f2: 0x0001, 0x6f3: 0x0001, 0x6f4: 0x0001, 0x6f5: 0x0001, 0x6f6: 0x0001, 0x6f7: 0x0001, 0x6f8: 0x0001, 0x6f9: 0x0001, 0x6fa: 0x0008, 0x6fb: 0x0008, 0x6fc: 0x0008, 0x6fd: 0x0001, 0x6fe: 0x0008, 0x6ff: 0x0008, // Block 0x1c, offset 0x700 0x700: 0x0008, 0x701: 0x0008, 0x702: 0x0008, 0x703: 0x0008, 0x704: 0x0008, 0x705: 0x0008, 0x706: 0x0008, 0x707: 0x0008, 0x708: 0x0008, 0x709: 0x0008, 0x70a: 0x0008, 0x70b: 0x0008, 0x70c: 0x0008, 0x70d: 0x0008, 0x70e: 0x0008, 0x70f: 0x0008, 0x710: 0x0001, 0x711: 0x0008, 0x712: 0x0008, 0x713: 0x0008, 0x714: 0x0008, 0x715: 0x0008, 0x716: 0x0008, 0x717: 0x0008, 0x718: 0x0001, 0x719: 0x0001, 0x71a: 0x0001, 0x71b: 0x0001, 0x71c: 0x0001, 0x71d: 0x0001, 0x71e: 0x0001, 0x71f: 0x0001, 0x720: 0x0001, 0x721: 0x0001, 0x722: 0x0008, 0x723: 0x0008, 0x726: 0x4000, 0x727: 0x4000, 0x728: 0x4000, 0x729: 0x4000, 0x72a: 0x4000, 0x72b: 0x4000, 0x72c: 0x4000, 0x72d: 0x4000, 0x72e: 0x4000, 0x72f: 0x4000, 0x731: 0x0001, 0x732: 0x0001, 0x733: 0x0001, 0x734: 0x0001, 0x735: 0x0001, 0x736: 0x0001, 0x737: 0x0001, 0x738: 0x0001, 0x739: 0x0001, 0x73a: 0x0001, 0x73b: 0x0001, 0x73c: 0x0001, 0x73d: 0x0001, 0x73e: 0x0001, 0x73f: 0x0001, // Block 0x1d, offset 0x740 0x740: 0x0001, 0x741: 0x0008, 0x742: 0x0008, 0x743: 0x0008, 0x745: 0x0001, 0x746: 0x0001, 0x747: 0x0001, 0x748: 0x0001, 0x749: 0x0001, 0x74a: 0x0001, 0x74b: 0x0001, 0x74c: 0x0001, 0x74f: 0x0001, 0x750: 0x0001, 0x753: 0x0001, 0x754: 0x0001, 0x755: 0x0001, 0x756: 0x0001, 0x757: 0x0001, 0x758: 0x0001, 0x759: 0x0001, 0x75a: 0x0001, 0x75b: 0x0001, 0x75c: 0x0001, 0x75d: 0x0001, 0x75e: 0x0001, 0x75f: 0x0001, 0x760: 0x0001, 0x761: 0x0001, 0x762: 0x0001, 0x763: 0x0001, 0x764: 0x0001, 0x765: 0x0001, 0x766: 0x0001, 0x767: 0x0001, 0x768: 0x0001, 0x76a: 0x0001, 0x76b: 0x0001, 0x76c: 0x0001, 0x76d: 0x0001, 0x76e: 0x0001, 0x76f: 0x0001, 0x770: 0x0001, 0x772: 0x0001, 0x776: 0x0001, 0x777: 0x0001, 0x778: 0x0001, 0x779: 0x0001, 0x77c: 0x0008, 0x77d: 0x0001, 0x77e: 0x0008, 0x77f: 0x0008, // Block 0x1e, offset 0x780 0x780: 0x0008, 0x781: 0x0008, 0x782: 0x0008, 0x783: 0x0008, 0x784: 0x0008, 0x787: 0x0008, 0x788: 0x0008, 0x78b: 0x0008, 0x78c: 0x0008, 0x78d: 0x0008, 0x78e: 0x0001, 0x797: 0x0008, 0x79c: 0x0001, 0x79d: 0x0001, 0x79f: 0x0001, 0x7a0: 0x0001, 0x7a1: 0x0001, 0x7a2: 0x0008, 0x7a3: 0x0008, 0x7a6: 0x4000, 0x7a7: 0x4000, 0x7a8: 0x4000, 0x7a9: 0x4000, 0x7aa: 0x4000, 0x7ab: 0x4000, 0x7ac: 0x4000, 0x7ad: 0x4000, 0x7ae: 0x4000, 0x7af: 0x4000, 0x7b0: 0x0001, 0x7b1: 0x0001, 0x7bc: 0x0001, 0x7be: 0x0008, // Block 0x1f, offset 0x7c0 0x7c1: 0x0008, 0x7c2: 0x0008, 0x7c3: 0x0008, 0x7c5: 0x0001, 0x7c6: 0x0001, 0x7c7: 0x0001, 0x7c8: 0x0001, 0x7c9: 0x0001, 0x7ca: 0x0001, 0x7cf: 0x0001, 0x7d0: 0x0001, 0x7d3: 0x0001, 0x7d4: 0x0001, 0x7d5: 0x0001, 0x7d6: 0x0001, 0x7d7: 0x0001, 0x7d8: 0x0001, 0x7d9: 0x0001, 0x7da: 0x0001, 0x7db: 0x0001, 0x7dc: 0x0001, 0x7dd: 0x0001, 0x7de: 0x0001, 0x7df: 0x0001, 0x7e0: 0x0001, 0x7e1: 0x0001, 0x7e2: 0x0001, 0x7e3: 0x0001, 0x7e4: 0x0001, 0x7e5: 0x0001, 0x7e6: 0x0001, 0x7e7: 0x0001, 0x7e8: 0x0001, 0x7ea: 0x0001, 0x7eb: 0x0001, 0x7ec: 0x0001, 0x7ed: 0x0001, 0x7ee: 0x0001, 0x7ef: 0x0001, 0x7f0: 0x0001, 0x7f2: 0x0001, 0x7f3: 0x0001, 0x7f5: 0x0001, 0x7f6: 0x0001, 0x7f8: 0x0001, 0x7f9: 0x0001, 0x7fc: 0x0008, 0x7fe: 0x0008, 0x7ff: 0x0008, // Block 0x20, offset 0x800 0x800: 0x0008, 0x801: 0x0008, 0x802: 0x0008, 0x807: 0x0008, 0x808: 0x0008, 0x80b: 0x0008, 0x80c: 0x0008, 0x80d: 0x0008, 0x811: 0x0008, 0x819: 0x0001, 0x81a: 0x0001, 0x81b: 0x0001, 0x81c: 0x0001, 0x81e: 0x0001, 0x826: 0x4000, 0x827: 0x4000, 0x828: 0x4000, 0x829: 0x4000, 0x82a: 0x4000, 0x82b: 0x4000, 0x82c: 0x4000, 0x82d: 0x4000, 0x82e: 0x4000, 0x82f: 0x4000, 0x830: 0x0008, 0x831: 0x0008, 0x832: 0x0001, 0x833: 0x0001, 0x834: 0x0001, 0x835: 0x0008, // Block 0x21, offset 0x840 0x841: 0x0008, 0x842: 0x0008, 0x843: 0x0008, 0x845: 0x0001, 0x846: 0x0001, 0x847: 0x0001, 0x848: 0x0001, 0x849: 0x0001, 0x84a: 0x0001, 0x84b: 0x0001, 0x84c: 0x0001, 0x84d: 0x0001, 0x84f: 0x0001, 0x850: 0x0001, 0x851: 0x0001, 0x853: 0x0001, 0x854: 0x0001, 0x855: 0x0001, 0x856: 0x0001, 0x857: 0x0001, 0x858: 0x0001, 0x859: 0x0001, 0x85a: 0x0001, 0x85b: 0x0001, 0x85c: 0x0001, 0x85d: 0x0001, 0x85e: 0x0001, 0x85f: 0x0001, 0x860: 0x0001, 0x861: 0x0001, 0x862: 0x0001, 0x863: 0x0001, 0x864: 0x0001, 0x865: 0x0001, 0x866: 0x0001, 0x867: 0x0001, 0x868: 0x0001, 0x86a: 0x0001, 0x86b: 0x0001, 0x86c: 0x0001, 0x86d: 0x0001, 0x86e: 0x0001, 0x86f: 0x0001, 0x870: 0x0001, 0x872: 0x0001, 0x873: 0x0001, 0x875: 0x0001, 0x876: 0x0001, 0x877: 0x0001, 0x878: 0x0001, 0x879: 0x0001, 0x87c: 0x0008, 0x87d: 0x0001, 0x87e: 0x0008, 0x87f: 0x0008, // Block 0x22, offset 0x880 0x880: 0x0008, 0x881: 0x0008, 0x882: 0x0008, 0x883: 0x0008, 0x884: 0x0008, 0x885: 0x0008, 0x887: 0x0008, 0x888: 0x0008, 0x889: 0x0008, 0x88b: 0x0008, 0x88c: 0x0008, 0x88d: 0x0008, 0x890: 0x0001, 0x8a0: 0x0001, 0x8a1: 0x0001, 0x8a2: 0x0008, 0x8a3: 0x0008, 0x8a6: 0x4000, 0x8a7: 0x4000, 0x8a8: 0x4000, 0x8a9: 0x4000, 0x8aa: 0x4000, 0x8ab: 0x4000, 0x8ac: 0x4000, 0x8ad: 0x4000, 0x8ae: 0x4000, 0x8af: 0x4000, 0x8b9: 0x0001, 0x8ba: 0x0008, 0x8bb: 0x0008, 0x8bc: 0x0008, 0x8bd: 0x0008, 0x8be: 0x0008, 0x8bf: 0x0008, // Block 0x23, offset 0x8c0 0x8c1: 0x0008, 0x8c2: 0x0008, 0x8c3: 0x0008, 0x8c5: 0x0001, 0x8c6: 0x0001, 0x8c7: 0x0001, 0x8c8: 0x0001, 0x8c9: 0x0001, 0x8ca: 0x0001, 0x8cb: 0x0001, 0x8cc: 0x0001, 0x8cf: 0x0001, 0x8d0: 0x0001, 0x8d3: 0x0001, 0x8d4: 0x0001, 0x8d5: 0x0001, 0x8d6: 0x0001, 0x8d7: 0x0001, 0x8d8: 0x0001, 0x8d9: 0x0001, 0x8da: 0x0001, 0x8db: 0x0001, 0x8dc: 0x0001, 0x8dd: 0x0001, 0x8de: 0x0001, 0x8df: 0x0001, 0x8e0: 0x0001, 0x8e1: 0x0001, 0x8e2: 0x0001, 0x8e3: 0x0001, 0x8e4: 0x0001, 0x8e5: 0x0001, 0x8e6: 0x0001, 0x8e7: 0x0001, 0x8e8: 0x0001, 0x8ea: 0x0001, 0x8eb: 0x0001, 0x8ec: 0x0001, 0x8ed: 0x0001, 0x8ee: 0x0001, 0x8ef: 0x0001, 0x8f0: 0x0001, 0x8f2: 0x0001, 0x8f3: 0x0001, 0x8f5: 0x0001, 0x8f6: 0x0001, 0x8f7: 0x0001, 0x8f8: 0x0001, 0x8f9: 0x0001, 0x8fc: 0x0008, 0x8fd: 0x0001, 0x8fe: 0x0008, 0x8ff: 0x0008, // Block 0x24, offset 0x900 0x900: 0x0008, 0x901: 0x0008, 0x902: 0x0008, 0x903: 0x0008, 0x904: 0x0008, 0x907: 0x0008, 0x908: 0x0008, 0x90b: 0x0008, 0x90c: 0x0008, 0x90d: 0x0008, 0x915: 0x0008, 0x916: 0x0008, 0x917: 0x0008, 0x91c: 0x0001, 0x91d: 0x0001, 0x91f: 0x0001, 0x920: 0x0001, 0x921: 0x0001, 0x922: 0x0008, 0x923: 0x0008, 0x926: 0x4000, 0x927: 0x4000, 0x928: 0x4000, 0x929: 0x4000, 0x92a: 0x4000, 0x92b: 0x4000, 0x92c: 0x4000, 0x92d: 0x4000, 0x92e: 0x4000, 0x92f: 0x4000, 0x931: 0x0001, // Block 0x25, offset 0x940 0x942: 0x0008, 0x943: 0x0001, 0x945: 0x0001, 0x946: 0x0001, 0x947: 0x0001, 0x948: 0x0001, 0x949: 0x0001, 0x94a: 0x0001, 0x94e: 0x0001, 0x94f: 0x0001, 0x950: 0x0001, 0x952: 0x0001, 0x953: 0x0001, 0x954: 0x0001, 0x955: 0x0001, 0x959: 0x0001, 0x95a: 0x0001, 0x95c: 0x0001, 0x95e: 0x0001, 0x95f: 0x0001, 0x963: 0x0001, 0x964: 0x0001, 0x968: 0x0001, 0x969: 0x0001, 0x96a: 0x0001, 0x96e: 0x0001, 0x96f: 0x0001, 0x970: 0x0001, 0x971: 0x0001, 0x972: 0x0001, 0x973: 0x0001, 0x974: 0x0001, 0x975: 0x0001, 0x976: 0x0001, 0x977: 0x0001, 0x978: 0x0001, 0x979: 0x0001, 0x97e: 0x0008, 0x97f: 0x0008, // Block 0x26, offset 0x980 0x980: 0x0008, 0x981: 0x0008, 0x982: 0x0008, 0x986: 0x0008, 0x987: 0x0008, 0x988: 0x0008, 0x98a: 0x0008, 0x98b: 0x0008, 0x98c: 0x0008, 0x98d: 0x0008, 0x990: 0x0001, 0x997: 0x0008, 0x9a6: 0x4000, 0x9a7: 0x4000, 0x9a8: 0x4000, 0x9a9: 0x4000, 0x9aa: 0x4000, 0x9ab: 0x4000, 0x9ac: 0x4000, 0x9ad: 0x4000, 0x9ae: 0x4000, 0x9af: 0x4000, // Block 0x27, offset 0x9c0 0x9c0: 0x0008, 0x9c1: 0x0008, 0x9c2: 0x0008, 0x9c3: 0x0008, 0x9c4: 0x0008, 0x9c5: 0x0001, 0x9c6: 0x0001, 0x9c7: 0x0001, 0x9c8: 0x0001, 0x9c9: 0x0001, 0x9ca: 0x0001, 0x9cb: 0x0001, 0x9cc: 0x0001, 0x9ce: 0x0001, 0x9cf: 0x0001, 0x9d0: 0x0001, 0x9d2: 0x0001, 0x9d3: 0x0001, 0x9d4: 0x0001, 0x9d5: 0x0001, 0x9d6: 0x0001, 0x9d7: 0x0001, 0x9d8: 0x0001, 0x9d9: 0x0001, 0x9da: 0x0001, 0x9db: 0x0001, 0x9dc: 0x0001, 0x9dd: 0x0001, 0x9de: 0x0001, 0x9df: 0x0001, 0x9e0: 0x0001, 0x9e1: 0x0001, 0x9e2: 0x0001, 0x9e3: 0x0001, 0x9e4: 0x0001, 0x9e5: 0x0001, 0x9e6: 0x0001, 0x9e7: 0x0001, 0x9e8: 0x0001, 0x9ea: 0x0001, 0x9eb: 0x0001, 0x9ec: 0x0001, 0x9ed: 0x0001, 0x9ee: 0x0001, 0x9ef: 0x0001, 0x9f0: 0x0001, 0x9f1: 0x0001, 0x9f2: 0x0001, 0x9f3: 0x0001, 0x9f4: 0x0001, 0x9f5: 0x0001, 0x9f6: 0x0001, 0x9f7: 0x0001, 0x9f8: 0x0001, 0x9f9: 0x0001, 0x9fc: 0x0008, 0x9fd: 0x0001, 0x9fe: 0x0008, 0x9ff: 0x0008, // Block 0x28, offset 0xa00 0xa00: 0x0008, 0xa01: 0x0008, 0xa02: 0x0008, 0xa03: 0x0008, 0xa04: 0x0008, 0xa06: 0x0008, 0xa07: 0x0008, 0xa08: 0x0008, 0xa0a: 0x0008, 0xa0b: 0x0008, 0xa0c: 0x0008, 0xa0d: 0x0008, 0xa15: 0x0008, 0xa16: 0x0008, 0xa18: 0x0001, 0xa19: 0x0001, 0xa1a: 0x0001, 0xa1c: 0x0001, 0xa1d: 0x0001, 0xa20: 0x0001, 0xa21: 0x0001, 0xa22: 0x0008, 0xa23: 0x0008, 0xa26: 0x4000, 0xa27: 0x4000, 0xa28: 0x4000, 0xa29: 0x4000, 0xa2a: 0x4000, 0xa2b: 0x4000, 0xa2c: 0x4000, 0xa2d: 0x4000, 0xa2e: 0x4000, 0xa2f: 0x4000, // Block 0x29, offset 0xa40 0xa40: 0x0001, 0xa41: 0x0008, 0xa42: 0x0008, 0xa43: 0x0008, 0xa45: 0x0001, 0xa46: 0x0001, 0xa47: 0x0001, 0xa48: 0x0001, 0xa49: 0x0001, 0xa4a: 0x0001, 0xa4b: 0x0001, 0xa4c: 0x0001, 0xa4e: 0x0001, 0xa4f: 0x0001, 0xa50: 0x0001, 0xa52: 0x0001, 0xa53: 0x0001, 0xa54: 0x0001, 0xa55: 0x0001, 0xa56: 0x0001, 0xa57: 0x0001, 0xa58: 0x0001, 0xa59: 0x0001, 0xa5a: 0x0001, 0xa5b: 0x0001, 0xa5c: 0x0001, 0xa5d: 0x0001, 0xa5e: 0x0001, 0xa5f: 0x0001, 0xa60: 0x0001, 0xa61: 0x0001, 0xa62: 0x0001, 0xa63: 0x0001, 0xa64: 0x0001, 0xa65: 0x0001, 0xa66: 0x0001, 0xa67: 0x0001, 0xa68: 0x0001, 0xa6a: 0x0001, 0xa6b: 0x0001, 0xa6c: 0x0001, 0xa6d: 0x0001, 0xa6e: 0x0001, 0xa6f: 0x0001, 0xa70: 0x0001, 0xa71: 0x0001, 0xa72: 0x0001, 0xa73: 0x0001, 0xa75: 0x0001, 0xa76: 0x0001, 0xa77: 0x0001, 0xa78: 0x0001, 0xa79: 0x0001, 0xa7c: 0x0008, 0xa7d: 0x0001, 0xa7e: 0x0008, 0xa7f: 0x0008, // Block 0x2a, offset 0xa80 0xa80: 0x0008, 0xa81: 0x0008, 0xa82: 0x0008, 0xa83: 0x0008, 0xa84: 0x0008, 0xa86: 0x0008, 0xa87: 0x0008, 0xa88: 0x0008, 0xa8a: 0x0008, 0xa8b: 0x0008, 0xa8c: 0x0008, 0xa8d: 0x0008, 0xa95: 0x0008, 0xa96: 0x0008, 0xa9c: 0x0001, 0xa9d: 0x0001, 0xa9e: 0x0001, 0xaa0: 0x0001, 0xaa1: 0x0001, 0xaa2: 0x0008, 0xaa3: 0x0008, 0xaa6: 0x4000, 0xaa7: 0x4000, 0xaa8: 0x4000, 0xaa9: 0x4000, 0xaaa: 0x4000, 0xaab: 0x4000, 0xaac: 0x4000, 0xaad: 0x4000, 0xaae: 0x4000, 0xaaf: 0x4000, 0xab1: 0x0001, 0xab2: 0x0001, 0xab3: 0x0008, // Block 0x2b, offset 0xac0 0xac0: 0x0008, 0xac1: 0x0008, 0xac2: 0x0008, 0xac3: 0x0008, 0xac4: 0x0001, 0xac5: 0x0001, 0xac6: 0x0001, 0xac7: 0x0001, 0xac8: 0x0001, 0xac9: 0x0001, 0xaca: 0x0001, 0xacb: 0x0001, 0xacc: 0x0001, 0xace: 0x0001, 0xacf: 0x0001, 0xad0: 0x0001, 0xad2: 0x0001, 0xad3: 0x0001, 0xad4: 0x0001, 0xad5: 0x0001, 0xad6: 0x0001, 0xad7: 0x0001, 0xad8: 0x0001, 0xad9: 0x0001, 0xada: 0x0001, 0xadb: 0x0001, 0xadc: 0x0001, 0xadd: 0x0001, 0xade: 0x0001, 0xadf: 0x0001, 0xae0: 0x0001, 0xae1: 0x0001, 0xae2: 0x0001, 0xae3: 0x0001, 0xae4: 0x0001, 0xae5: 0x0001, 0xae6: 0x0001, 0xae7: 0x0001, 0xae8: 0x0001, 0xae9: 0x0001, 0xaea: 0x0001, 0xaeb: 0x0001, 0xaec: 0x0001, 0xaed: 0x0001, 0xaee: 0x0001, 0xaef: 0x0001, 0xaf0: 0x0001, 0xaf1: 0x0001, 0xaf2: 0x0001, 0xaf3: 0x0001, 0xaf4: 0x0001, 0xaf5: 0x0001, 0xaf6: 0x0001, 0xaf7: 0x0001, 0xaf8: 0x0001, 0xaf9: 0x0001, 0xafa: 0x0001, 0xafb: 0x0008, 0xafc: 0x0008, 0xafd: 0x0001, 0xafe: 0x0008, 0xaff: 0x0008, // Block 0x2c, offset 0xb00 0xb00: 0x0008, 0xb01: 0x0008, 0xb02: 0x0008, 0xb03: 0x0008, 0xb04: 0x0008, 0xb06: 0x0008, 0xb07: 0x0008, 0xb08: 0x0008, 0xb0a: 0x0008, 0xb0b: 0x0008, 0xb0c: 0x0008, 0xb0d: 0x0008, 0xb0e: 0x0001, 0xb14: 0x0001, 0xb15: 0x0001, 0xb16: 0x0001, 0xb17: 0x0008, 0xb1f: 0x0001, 0xb20: 0x0001, 0xb21: 0x0001, 0xb22: 0x0008, 0xb23: 0x0008, 0xb26: 0x4000, 0xb27: 0x4000, 0xb28: 0x4000, 0xb29: 0x4000, 0xb2a: 0x4000, 0xb2b: 0x4000, 0xb2c: 0x4000, 0xb2d: 0x4000, 0xb2e: 0x4000, 0xb2f: 0x4000, 0xb3a: 0x0001, 0xb3b: 0x0001, 0xb3c: 0x0001, 0xb3d: 0x0001, 0xb3e: 0x0001, 0xb3f: 0x0001, // Block 0x2d, offset 0xb40 0xb41: 0x0008, 0xb42: 0x0008, 0xb43: 0x0008, 0xb45: 0x0001, 0xb46: 0x0001, 0xb47: 0x0001, 0xb48: 0x0001, 0xb49: 0x0001, 0xb4a: 0x0001, 0xb4b: 0x0001, 0xb4c: 0x0001, 0xb4d: 0x0001, 0xb4e: 0x0001, 0xb4f: 0x0001, 0xb50: 0x0001, 0xb51: 0x0001, 0xb52: 0x0001, 0xb53: 0x0001, 0xb54: 0x0001, 0xb55: 0x0001, 0xb56: 0x0001, 0xb5a: 0x0001, 0xb5b: 0x0001, 0xb5c: 0x0001, 0xb5d: 0x0001, 0xb5e: 0x0001, 0xb5f: 0x0001, 0xb60: 0x0001, 0xb61: 0x0001, 0xb62: 0x0001, 0xb63: 0x0001, 0xb64: 0x0001, 0xb65: 0x0001, 0xb66: 0x0001, 0xb67: 0x0001, 0xb68: 0x0001, 0xb69: 0x0001, 0xb6a: 0x0001, 0xb6b: 0x0001, 0xb6c: 0x0001, 0xb6d: 0x0001, 0xb6e: 0x0001, 0xb6f: 0x0001, 0xb70: 0x0001, 0xb71: 0x0001, 0xb73: 0x0001, 0xb74: 0x0001, 0xb75: 0x0001, 0xb76: 0x0001, 0xb77: 0x0001, 0xb78: 0x0001, 0xb79: 0x0001, 0xb7a: 0x0001, 0xb7b: 0x0001, 0xb7d: 0x0001, // Block 0x2e, offset 0xb80 0xb80: 0x0001, 0xb81: 0x0001, 0xb82: 0x0001, 0xb83: 0x0001, 0xb84: 0x0001, 0xb85: 0x0001, 0xb86: 0x0001, 0xb8a: 0x0008, 0xb8f: 0x0008, 0xb90: 0x0008, 0xb91: 0x0008, 0xb92: 0x0008, 0xb93: 0x0008, 0xb94: 0x0008, 0xb96: 0x0008, 0xb98: 0x0008, 0xb99: 0x0008, 0xb9a: 0x0008, 0xb9b: 0x0008, 0xb9c: 0x0008, 0xb9d: 0x0008, 0xb9e: 0x0008, 0xb9f: 0x0008, 0xba6: 0x4000, 0xba7: 0x4000, 0xba8: 0x4000, 0xba9: 0x4000, 0xbaa: 0x4000, 0xbab: 0x4000, 0xbac: 0x4000, 0xbad: 0x4000, 0xbae: 0x4000, 0xbaf: 0x4000, 0xbb2: 0x0008, 0xbb3: 0x0008, // Block 0x2f, offset 0xbc0 0xbf1: 0x0008, 0xbf4: 0x0008, 0xbf5: 0x0008, 0xbf6: 0x0008, 0xbf7: 0x0008, 0xbf8: 0x0008, 0xbf9: 0x0008, 0xbfa: 0x0008, // Block 0x30, offset 0xc00 0xc07: 0x0008, 0xc08: 0x0008, 0xc09: 0x0008, 0xc0a: 0x0008, 0xc0b: 0x0008, 0xc0c: 0x0008, 0xc0d: 0x0008, 0xc0e: 0x0008, 0xc10: 0x4000, 0xc11: 0x4000, 0xc12: 0x4000, 0xc13: 0x4000, 0xc14: 0x4000, 0xc15: 0x4000, 0xc16: 0x4000, 0xc17: 0x4000, 0xc18: 0x4000, 0xc19: 0x4000, // Block 0x31, offset 0xc40 0xc71: 0x0008, 0xc74: 0x0008, 0xc75: 0x0008, 0xc76: 0x0008, 0xc77: 0x0008, 0xc78: 0x0008, 0xc79: 0x0008, 0xc7a: 0x0008, 0xc7b: 0x0008, 0xc7c: 0x0008, // Block 0x32, offset 0xc80 0xc88: 0x0008, 0xc89: 0x0008, 0xc8a: 0x0008, 0xc8b: 0x0008, 0xc8c: 0x0008, 0xc8d: 0x0008, 0xc8e: 0x0008, 0xc90: 0x4000, 0xc91: 0x4000, 0xc92: 0x4000, 0xc93: 0x4000, 0xc94: 0x4000, 0xc95: 0x4000, 0xc96: 0x4000, 0xc97: 0x4000, 0xc98: 0x4000, 0xc99: 0x4000, // Block 0x33, offset 0xcc0 0xcc0: 0x0001, 0xcd8: 0x0008, 0xcd9: 0x0008, 0xce0: 0x4000, 0xce1: 0x4000, 0xce2: 0x4000, 0xce3: 0x4000, 0xce4: 0x4000, 0xce5: 0x4000, 0xce6: 0x4000, 0xce7: 0x4000, 0xce8: 0x4000, 0xce9: 0x4000, 0xcf5: 0x0008, 0xcf7: 0x0008, 0xcf9: 0x0008, 0xcfe: 0x0008, 0xcff: 0x0008, // Block 0x34, offset 0xd00 0xd00: 0x0001, 0xd01: 0x0001, 0xd02: 0x0001, 0xd03: 0x0001, 0xd04: 0x0001, 0xd05: 0x0001, 0xd06: 0x0001, 0xd07: 0x0001, 0xd09: 0x0001, 0xd0a: 0x0001, 0xd0b: 0x0001, 0xd0c: 0x0001, 0xd0d: 0x0001, 0xd0e: 0x0001, 0xd0f: 0x0001, 0xd10: 0x0001, 0xd11: 0x0001, 0xd12: 0x0001, 0xd13: 0x0001, 0xd14: 0x0001, 0xd15: 0x0001, 0xd16: 0x0001, 0xd17: 0x0001, 0xd18: 0x0001, 0xd19: 0x0001, 0xd1a: 0x0001, 0xd1b: 0x0001, 0xd1c: 0x0001, 0xd1d: 0x0001, 0xd1e: 0x0001, 0xd1f: 0x0001, 0xd20: 0x0001, 0xd21: 0x0001, 0xd22: 0x0001, 0xd23: 0x0001, 0xd24: 0x0001, 0xd25: 0x0001, 0xd26: 0x0001, 0xd27: 0x0001, 0xd28: 0x0001, 0xd29: 0x0001, 0xd2a: 0x0001, 0xd2b: 0x0001, 0xd2c: 0x0001, 0xd31: 0x0008, 0xd32: 0x0008, 0xd33: 0x0008, 0xd34: 0x0008, 0xd35: 0x0008, 0xd36: 0x0008, 0xd37: 0x0008, 0xd38: 0x0008, 0xd39: 0x0008, 0xd3a: 0x0008, 0xd3b: 0x0008, 0xd3c: 0x0008, 0xd3d: 0x0008, 0xd3e: 0x0008, 0xd3f: 0x0008, // Block 0x35, offset 0xd40 0xd40: 0x0008, 0xd41: 0x0008, 0xd42: 0x0008, 0xd43: 0x0008, 0xd44: 0x0008, 0xd46: 0x0008, 0xd47: 0x0008, 0xd48: 0x0001, 0xd49: 0x0001, 0xd4a: 0x0001, 0xd4b: 0x0001, 0xd4c: 0x0001, 0xd4d: 0x0008, 0xd4e: 0x0008, 0xd4f: 0x0008, 0xd50: 0x0008, 0xd51: 0x0008, 0xd52: 0x0008, 0xd53: 0x0008, 0xd54: 0x0008, 0xd55: 0x0008, 0xd56: 0x0008, 0xd57: 0x0008, 0xd59: 0x0008, 0xd5a: 0x0008, 0xd5b: 0x0008, 0xd5c: 0x0008, 0xd5d: 0x0008, 0xd5e: 0x0008, 0xd5f: 0x0008, 0xd60: 0x0008, 0xd61: 0x0008, 0xd62: 0x0008, 0xd63: 0x0008, 0xd64: 0x0008, 0xd65: 0x0008, 0xd66: 0x0008, 0xd67: 0x0008, 0xd68: 0x0008, 0xd69: 0x0008, 0xd6a: 0x0008, 0xd6b: 0x0008, 0xd6c: 0x0008, 0xd6d: 0x0008, 0xd6e: 0x0008, 0xd6f: 0x0008, 0xd70: 0x0008, 0xd71: 0x0008, 0xd72: 0x0008, 0xd73: 0x0008, 0xd74: 0x0008, 0xd75: 0x0008, 0xd76: 0x0008, 0xd77: 0x0008, 0xd78: 0x0008, 0xd79: 0x0008, 0xd7a: 0x0008, 0xd7b: 0x0008, 0xd7c: 0x0008, // Block 0x36, offset 0xd80 0xd86: 0x0008, // Block 0x37, offset 0xdc0 0xdeb: 0x0008, 0xdec: 0x0008, 0xded: 0x0008, 0xdee: 0x0008, 0xdef: 0x0008, 0xdf0: 0x0008, 0xdf1: 0x0008, 0xdf2: 0x0008, 0xdf3: 0x0008, 0xdf4: 0x0008, 0xdf5: 0x0008, 0xdf6: 0x0008, 0xdf7: 0x0008, 0xdf8: 0x0008, 0xdf9: 0x0008, 0xdfa: 0x0008, 0xdfb: 0x0008, 0xdfc: 0x0008, 0xdfd: 0x0008, 0xdfe: 0x0008, // Block 0x38, offset 0xe00 0xe00: 0x4000, 0xe01: 0x4000, 0xe02: 0x4000, 0xe03: 0x4000, 0xe04: 0x4000, 0xe05: 0x4000, 0xe06: 0x4000, 0xe07: 0x4000, 0xe08: 0x4000, 0xe09: 0x4000, 0xe16: 0x0008, 0xe17: 0x0008, 0xe18: 0x0008, 0xe19: 0x0008, 0xe1e: 0x0008, 0xe1f: 0x0008, 0xe20: 0x0008, 0xe22: 0x0008, 0xe23: 0x0008, 0xe24: 0x0008, 0xe27: 0x0008, 0xe28: 0x0008, 0xe29: 0x0008, 0xe2a: 0x0008, 0xe2b: 0x0008, 0xe2c: 0x0008, 0xe2d: 0x0008, 0xe31: 0x0008, 0xe32: 0x0008, 0xe33: 0x0008, 0xe34: 0x0008, // Block 0x39, offset 0xe40 0xe42: 0x0008, 0xe43: 0x0008, 0xe44: 0x0008, 0xe45: 0x0008, 0xe46: 0x0008, 0xe47: 0x0008, 0xe48: 0x0008, 0xe49: 0x0008, 0xe4a: 0x0008, 0xe4b: 0x0008, 0xe4c: 0x0008, 0xe4d: 0x0008, 0xe4f: 0x0008, 0xe50: 0x4000, 0xe51: 0x4000, 0xe52: 0x4000, 0xe53: 0x4000, 0xe54: 0x4000, 0xe55: 0x4000, 0xe56: 0x4000, 0xe57: 0x4000, 0xe58: 0x4000, 0xe59: 0x4000, 0xe5a: 0x0008, 0xe5b: 0x0008, 0xe5c: 0x0008, 0xe5d: 0x0008, 0xe60: 0x0001, 0xe61: 0x0001, 0xe62: 0x0001, 0xe63: 0x0001, 0xe64: 0x0001, 0xe65: 0x0001, 0xe66: 0x0001, 0xe67: 0x0001, 0xe68: 0x0001, 0xe69: 0x0001, 0xe6a: 0x0001, 0xe6b: 0x0001, 0xe6c: 0x0001, 0xe6d: 0x0001, 0xe6e: 0x0001, 0xe6f: 0x0001, 0xe70: 0x0001, 0xe71: 0x0001, 0xe72: 0x0001, 0xe73: 0x0001, 0xe74: 0x0001, 0xe75: 0x0001, 0xe76: 0x0001, 0xe77: 0x0001, 0xe78: 0x0001, 0xe79: 0x0001, 0xe7a: 0x0001, 0xe7b: 0x0001, 0xe7c: 0x0001, 0xe7d: 0x0001, 0xe7e: 0x0001, 0xe7f: 0x0001, // Block 0x3a, offset 0xe80 0xe80: 0x0001, 0xe81: 0x0001, 0xe82: 0x0001, 0xe83: 0x0001, 0xe84: 0x0001, 0xe85: 0x0001, 0xe87: 0x0001, 0xe8d: 0x0001, 0xe90: 0x0001, 0xe91: 0x0001, 0xe92: 0x0001, 0xe93: 0x0001, 0xe94: 0x0001, 0xe95: 0x0001, 0xe96: 0x0001, 0xe97: 0x0001, 0xe98: 0x0001, 0xe99: 0x0001, 0xe9a: 0x0001, 0xe9b: 0x0001, 0xe9c: 0x0001, 0xe9d: 0x0001, 0xe9e: 0x0001, 0xe9f: 0x0001, 0xea0: 0x0001, 0xea1: 0x0001, 0xea2: 0x0001, 0xea3: 0x0001, 0xea4: 0x0001, 0xea5: 0x0001, 0xea6: 0x0001, 0xea7: 0x0001, 0xea8: 0x0001, 0xea9: 0x0001, 0xeaa: 0x0001, 0xeab: 0x0001, 0xeac: 0x0001, 0xead: 0x0001, 0xeae: 0x0001, 0xeaf: 0x0001, 0xeb0: 0x0001, 0xeb1: 0x0001, 0xeb2: 0x0001, 0xeb3: 0x0001, 0xeb4: 0x0001, 0xeb5: 0x0001, 0xeb6: 0x0001, 0xeb7: 0x0001, 0xeb8: 0x0001, 0xeb9: 0x0001, 0xeba: 0x0001, 0xebc: 0x0001, 0xebd: 0x0001, 0xebe: 0x0001, 0xebf: 0x0001, // Block 0x3b, offset 0xec0 0xec0: 0x0001, 0xec1: 0x0001, 0xec2: 0x0001, 0xec3: 0x0001, 0xec4: 0x0001, 0xec5: 0x0001, 0xec6: 0x0001, 0xec7: 0x0001, 0xec8: 0x0001, 0xeca: 0x0001, 0xecb: 0x0001, 0xecc: 0x0001, 0xecd: 0x0001, 0xed0: 0x0001, 0xed1: 0x0001, 0xed2: 0x0001, 0xed3: 0x0001, 0xed4: 0x0001, 0xed5: 0x0001, 0xed6: 0x0001, 0xed8: 0x0001, 0xeda: 0x0001, 0xedb: 0x0001, 0xedc: 0x0001, 0xedd: 0x0001, 0xee0: 0x0001, 0xee1: 0x0001, 0xee2: 0x0001, 0xee3: 0x0001, 0xee4: 0x0001, 0xee5: 0x0001, 0xee6: 0x0001, 0xee7: 0x0001, 0xee8: 0x0001, 0xee9: 0x0001, 0xeea: 0x0001, 0xeeb: 0x0001, 0xeec: 0x0001, 0xeed: 0x0001, 0xeee: 0x0001, 0xeef: 0x0001, 0xef0: 0x0001, 0xef1: 0x0001, 0xef2: 0x0001, 0xef3: 0x0001, 0xef4: 0x0001, 0xef5: 0x0001, 0xef6: 0x0001, 0xef7: 0x0001, 0xef8: 0x0001, 0xef9: 0x0001, 0xefa: 0x0001, 0xefb: 0x0001, 0xefc: 0x0001, 0xefd: 0x0001, 0xefe: 0x0001, 0xeff: 0x0001, // Block 0x3c, offset 0xf00 0xf00: 0x0001, 0xf01: 0x0001, 0xf02: 0x0001, 0xf03: 0x0001, 0xf04: 0x0001, 0xf05: 0x0001, 0xf06: 0x0001, 0xf07: 0x0001, 0xf08: 0x0001, 0xf0a: 0x0001, 0xf0b: 0x0001, 0xf0c: 0x0001, 0xf0d: 0x0001, 0xf10: 0x0001, 0xf11: 0x0001, 0xf12: 0x0001, 0xf13: 0x0001, 0xf14: 0x0001, 0xf15: 0x0001, 0xf16: 0x0001, 0xf17: 0x0001, 0xf18: 0x0001, 0xf19: 0x0001, 0xf1a: 0x0001, 0xf1b: 0x0001, 0xf1c: 0x0001, 0xf1d: 0x0001, 0xf1e: 0x0001, 0xf1f: 0x0001, 0xf20: 0x0001, 0xf21: 0x0001, 0xf22: 0x0001, 0xf23: 0x0001, 0xf24: 0x0001, 0xf25: 0x0001, 0xf26: 0x0001, 0xf27: 0x0001, 0xf28: 0x0001, 0xf29: 0x0001, 0xf2a: 0x0001, 0xf2b: 0x0001, 0xf2c: 0x0001, 0xf2d: 0x0001, 0xf2e: 0x0001, 0xf2f: 0x0001, 0xf30: 0x0001, 0xf32: 0x0001, 0xf33: 0x0001, 0xf34: 0x0001, 0xf35: 0x0001, 0xf38: 0x0001, 0xf39: 0x0001, 0xf3a: 0x0001, 0xf3b: 0x0001, 0xf3c: 0x0001, 0xf3d: 0x0001, 0xf3e: 0x0001, // Block 0x3d, offset 0xf40 0xf40: 0x0001, 0xf42: 0x0001, 0xf43: 0x0001, 0xf44: 0x0001, 0xf45: 0x0001, 0xf48: 0x0001, 0xf49: 0x0001, 0xf4a: 0x0001, 0xf4b: 0x0001, 0xf4c: 0x0001, 0xf4d: 0x0001, 0xf4e: 0x0001, 0xf4f: 0x0001, 0xf50: 0x0001, 0xf51: 0x0001, 0xf52: 0x0001, 0xf53: 0x0001, 0xf54: 0x0001, 0xf55: 0x0001, 0xf56: 0x0001, 0xf58: 0x0001, 0xf59: 0x0001, 0xf5a: 0x0001, 0xf5b: 0x0001, 0xf5c: 0x0001, 0xf5d: 0x0001, 0xf5e: 0x0001, 0xf5f: 0x0001, 0xf60: 0x0001, 0xf61: 0x0001, 0xf62: 0x0001, 0xf63: 0x0001, 0xf64: 0x0001, 0xf65: 0x0001, 0xf66: 0x0001, 0xf67: 0x0001, 0xf68: 0x0001, 0xf69: 0x0001, 0xf6a: 0x0001, 0xf6b: 0x0001, 0xf6c: 0x0001, 0xf6d: 0x0001, 0xf6e: 0x0001, 0xf6f: 0x0001, 0xf70: 0x0001, 0xf71: 0x0001, 0xf72: 0x0001, 0xf73: 0x0001, 0xf74: 0x0001, 0xf75: 0x0001, 0xf76: 0x0001, 0xf77: 0x0001, 0xf78: 0x0001, 0xf79: 0x0001, 0xf7a: 0x0001, 0xf7b: 0x0001, 0xf7c: 0x0001, 0xf7d: 0x0001, 0xf7e: 0x0001, 0xf7f: 0x0001, // Block 0x3e, offset 0xf80 0xf80: 0x0001, 0xf81: 0x0001, 0xf82: 0x0001, 0xf83: 0x0001, 0xf84: 0x0001, 0xf85: 0x0001, 0xf86: 0x0001, 0xf87: 0x0001, 0xf88: 0x0001, 0xf89: 0x0001, 0xf8a: 0x0001, 0xf8b: 0x0001, 0xf8c: 0x0001, 0xf8d: 0x0001, 0xf8e: 0x0001, 0xf8f: 0x0001, 0xf90: 0x0001, 0xf92: 0x0001, 0xf93: 0x0001, 0xf94: 0x0001, 0xf95: 0x0001, 0xf98: 0x0001, 0xf99: 0x0001, 0xf9a: 0x0001, 0xf9b: 0x0001, 0xf9c: 0x0001, 0xf9d: 0x0001, 0xf9e: 0x0001, 0xf9f: 0x0001, 0xfa0: 0x0001, 0xfa1: 0x0001, 0xfa2: 0x0001, 0xfa3: 0x0001, 0xfa4: 0x0001, 0xfa5: 0x0001, 0xfa6: 0x0001, 0xfa7: 0x0001, 0xfa8: 0x0001, 0xfa9: 0x0001, 0xfaa: 0x0001, 0xfab: 0x0001, 0xfac: 0x0001, 0xfad: 0x0001, 0xfae: 0x0001, 0xfaf: 0x0001, 0xfb0: 0x0001, 0xfb1: 0x0001, 0xfb2: 0x0001, 0xfb3: 0x0001, 0xfb4: 0x0001, 0xfb5: 0x0001, 0xfb6: 0x0001, 0xfb7: 0x0001, 0xfb8: 0x0001, 0xfb9: 0x0001, 0xfba: 0x0001, 0xfbb: 0x0001, 0xfbc: 0x0001, 0xfbd: 0x0001, 0xfbe: 0x0001, 0xfbf: 0x0001, // Block 0x3f, offset 0xfc0 0xfc0: 0x0001, 0xfc1: 0x0001, 0xfc2: 0x0001, 0xfc3: 0x0001, 0xfc4: 0x0001, 0xfc5: 0x0001, 0xfc6: 0x0001, 0xfc7: 0x0001, 0xfc8: 0x0001, 0xfc9: 0x0001, 0xfca: 0x0001, 0xfcb: 0x0001, 0xfcc: 0x0001, 0xfcd: 0x0001, 0xfce: 0x0001, 0xfcf: 0x0001, 0xfd0: 0x0001, 0xfd1: 0x0001, 0xfd2: 0x0001, 0xfd3: 0x0001, 0xfd4: 0x0001, 0xfd5: 0x0001, 0xfd6: 0x0001, 0xfd7: 0x0001, 0xfd8: 0x0001, 0xfd9: 0x0001, 0xfda: 0x0001, 0xfdd: 0x0008, 0xfde: 0x0008, 0xfdf: 0x0008, // Block 0x40, offset 0x1000 0x1000: 0x0001, 0x1001: 0x0001, 0x1002: 0x0001, 0x1003: 0x0001, 0x1004: 0x0001, 0x1005: 0x0001, 0x1006: 0x0001, 0x1007: 0x0001, 0x1008: 0x0001, 0x1009: 0x0001, 0x100a: 0x0001, 0x100b: 0x0001, 0x100c: 0x0001, 0x100d: 0x0001, 0x100e: 0x0001, 0x100f: 0x0001, 0x1020: 0x0001, 0x1021: 0x0001, 0x1022: 0x0001, 0x1023: 0x0001, 0x1024: 0x0001, 0x1025: 0x0001, 0x1026: 0x0001, 0x1027: 0x0001, 0x1028: 0x0001, 0x1029: 0x0001, 0x102a: 0x0001, 0x102b: 0x0001, 0x102c: 0x0001, 0x102d: 0x0001, 0x102e: 0x0001, 0x102f: 0x0001, 0x1030: 0x0001, 0x1031: 0x0001, 0x1032: 0x0001, 0x1033: 0x0001, 0x1034: 0x0001, 0x1035: 0x0001, 0x1036: 0x0001, 0x1037: 0x0001, 0x1038: 0x0001, 0x1039: 0x0001, 0x103a: 0x0001, 0x103b: 0x0001, 0x103c: 0x0001, 0x103d: 0x0001, 0x103e: 0x0001, 0x103f: 0x0001, // Block 0x41, offset 0x1040 0x1040: 0x0001, 0x1041: 0x0001, 0x1042: 0x0001, 0x1043: 0x0001, 0x1044: 0x0001, 0x1045: 0x0001, 0x1046: 0x0001, 0x1047: 0x0001, 0x1048: 0x0001, 0x1049: 0x0001, 0x104a: 0x0001, 0x104b: 0x0001, 0x104c: 0x0001, 0x104d: 0x0001, 0x104e: 0x0001, 0x104f: 0x0001, 0x1050: 0x0001, 0x1051: 0x0001, 0x1052: 0x0001, 0x1053: 0x0001, 0x1054: 0x0001, 0x1055: 0x0001, 0x1056: 0x0001, 0x1057: 0x0001, 0x1058: 0x0001, 0x1059: 0x0001, 0x105a: 0x0001, 0x105b: 0x0001, 0x105c: 0x0001, 0x105d: 0x0001, 0x105e: 0x0001, 0x105f: 0x0001, 0x1060: 0x0001, 0x1061: 0x0001, 0x1062: 0x0001, 0x1063: 0x0001, 0x1064: 0x0001, 0x1065: 0x0001, 0x1066: 0x0001, 0x1067: 0x0001, 0x1068: 0x0001, 0x1069: 0x0001, 0x106a: 0x0001, 0x106b: 0x0001, 0x106c: 0x0001, 0x106d: 0x0001, 0x106e: 0x0001, 0x106f: 0x0001, 0x1070: 0x0001, 0x1071: 0x0001, 0x1072: 0x0001, 0x1073: 0x0001, 0x1074: 0x0001, 0x1075: 0x0001, 0x1078: 0x0001, 0x1079: 0x0001, 0x107a: 0x0001, 0x107b: 0x0001, 0x107c: 0x0001, 0x107d: 0x0001, // Block 0x42, offset 0x1080 0x1081: 0x0001, 0x1082: 0x0001, 0x1083: 0x0001, 0x1084: 0x0001, 0x1085: 0x0001, 0x1086: 0x0001, 0x1087: 0x0001, 0x1088: 0x0001, 0x1089: 0x0001, 0x108a: 0x0001, 0x108b: 0x0001, 0x108c: 0x0001, 0x108d: 0x0001, 0x108e: 0x0001, 0x108f: 0x0001, 0x1090: 0x0001, 0x1091: 0x0001, 0x1092: 0x0001, 0x1093: 0x0001, 0x1094: 0x0001, 0x1095: 0x0001, 0x1096: 0x0001, 0x1097: 0x0001, 0x1098: 0x0001, 0x1099: 0x0001, 0x109a: 0x0001, 0x109b: 0x0001, 0x109c: 0x0001, 0x109d: 0x0001, 0x109e: 0x0001, 0x109f: 0x0001, 0x10a0: 0x0001, 0x10a1: 0x0001, 0x10a2: 0x0001, 0x10a3: 0x0001, 0x10a4: 0x0001, 0x10a5: 0x0001, 0x10a6: 0x0001, 0x10a7: 0x0001, 0x10a8: 0x0001, 0x10a9: 0x0001, 0x10aa: 0x0001, 0x10ab: 0x0001, 0x10ac: 0x0001, 0x10ad: 0x0001, 0x10ae: 0x0001, 0x10af: 0x0001, 0x10b0: 0x0001, 0x10b1: 0x0001, 0x10b2: 0x0001, 0x10b3: 0x0001, 0x10b4: 0x0001, 0x10b5: 0x0001, 0x10b6: 0x0001, 0x10b7: 0x0001, 0x10b8: 0x0001, 0x10b9: 0x0001, 0x10ba: 0x0001, 0x10bb: 0x0001, 0x10bc: 0x0001, 0x10bd: 0x0001, 0x10be: 0x0001, 0x10bf: 0x0001, // Block 0x43, offset 0x10c0 0x10c0: 0x0001, 0x10c1: 0x0001, 0x10c2: 0x0001, 0x10c3: 0x0001, 0x10c4: 0x0001, 0x10c5: 0x0001, 0x10c6: 0x0001, 0x10c7: 0x0001, 0x10c8: 0x0001, 0x10c9: 0x0001, 0x10ca: 0x0001, 0x10cb: 0x0001, 0x10cc: 0x0001, 0x10cd: 0x0001, 0x10ce: 0x0001, 0x10cf: 0x0001, 0x10d0: 0x0001, 0x10d1: 0x0001, 0x10d2: 0x0001, 0x10d3: 0x0001, 0x10d4: 0x0001, 0x10d5: 0x0001, 0x10d6: 0x0001, 0x10d7: 0x0001, 0x10d8: 0x0001, 0x10d9: 0x0001, 0x10da: 0x0001, 0x10db: 0x0001, 0x10dc: 0x0001, 0x10dd: 0x0001, 0x10de: 0x0001, 0x10df: 0x0001, 0x10e0: 0x0001, 0x10e1: 0x0001, 0x10e2: 0x0001, 0x10e3: 0x0001, 0x10e4: 0x0001, 0x10e5: 0x0001, 0x10e6: 0x0001, 0x10e7: 0x0001, 0x10e8: 0x0001, 0x10e9: 0x0001, 0x10ea: 0x0001, 0x10eb: 0x0001, 0x10ec: 0x0001, 0x10ef: 0x0001, 0x10f0: 0x0001, 0x10f1: 0x0001, 0x10f2: 0x0001, 0x10f3: 0x0001, 0x10f4: 0x0001, 0x10f5: 0x0001, 0x10f6: 0x0001, 0x10f7: 0x0001, 0x10f8: 0x0001, 0x10f9: 0x0001, 0x10fa: 0x0001, 0x10fb: 0x0001, 0x10fc: 0x0001, 0x10fd: 0x0001, 0x10fe: 0x0001, 0x10ff: 0x0001, // Block 0x44, offset 0x1100 0x1100: 0x20000, 0x1101: 0x0001, 0x1102: 0x0001, 0x1103: 0x0001, 0x1104: 0x0001, 0x1105: 0x0001, 0x1106: 0x0001, 0x1107: 0x0001, 0x1108: 0x0001, 0x1109: 0x0001, 0x110a: 0x0001, 0x110b: 0x0001, 0x110c: 0x0001, 0x110d: 0x0001, 0x110e: 0x0001, 0x110f: 0x0001, 0x1110: 0x0001, 0x1111: 0x0001, 0x1112: 0x0001, 0x1113: 0x0001, 0x1114: 0x0001, 0x1115: 0x0001, 0x1116: 0x0001, 0x1117: 0x0001, 0x1118: 0x0001, 0x1119: 0x0001, 0x111a: 0x0001, 0x1120: 0x0001, 0x1121: 0x0001, 0x1122: 0x0001, 0x1123: 0x0001, 0x1124: 0x0001, 0x1125: 0x0001, 0x1126: 0x0001, 0x1127: 0x0001, 0x1128: 0x0001, 0x1129: 0x0001, 0x112a: 0x0001, 0x112b: 0x0001, 0x112c: 0x0001, 0x112d: 0x0001, 0x112e: 0x0001, 0x112f: 0x0001, 0x1130: 0x0001, 0x1131: 0x0001, 0x1132: 0x0001, 0x1133: 0x0001, 0x1134: 0x0001, 0x1135: 0x0001, 0x1136: 0x0001, 0x1137: 0x0001, 0x1138: 0x0001, 0x1139: 0x0001, 0x113a: 0x0001, 0x113b: 0x0001, 0x113c: 0x0001, 0x113d: 0x0001, 0x113e: 0x0001, 0x113f: 0x0001, // Block 0x45, offset 0x1140 0x1140: 0x0001, 0x1141: 0x0001, 0x1142: 0x0001, 0x1143: 0x0001, 0x1144: 0x0001, 0x1145: 0x0001, 0x1146: 0x0001, 0x1147: 0x0001, 0x1148: 0x0001, 0x1149: 0x0001, 0x114a: 0x0001, 0x114b: 0x0001, 0x114c: 0x0001, 0x114d: 0x0001, 0x114e: 0x0001, 0x114f: 0x0001, 0x1150: 0x0001, 0x1151: 0x0001, 0x1152: 0x0001, 0x1153: 0x0001, 0x1154: 0x0001, 0x1155: 0x0001, 0x1156: 0x0001, 0x1157: 0x0001, 0x1158: 0x0001, 0x1159: 0x0001, 0x115a: 0x0001, 0x115b: 0x0001, 0x115c: 0x0001, 0x115d: 0x0001, 0x115e: 0x0001, 0x115f: 0x0001, 0x1160: 0x0001, 0x1161: 0x0001, 0x1162: 0x0001, 0x1163: 0x0001, 0x1164: 0x0001, 0x1165: 0x0001, 0x1166: 0x0001, 0x1167: 0x0001, 0x1168: 0x0001, 0x1169: 0x0001, 0x116a: 0x0001, 0x116e: 0x0001, 0x116f: 0x0001, 0x1170: 0x0001, 0x1171: 0x0001, 0x1172: 0x0001, 0x1173: 0x0001, 0x1174: 0x0001, 0x1175: 0x0001, 0x1176: 0x0001, 0x1177: 0x0001, 0x1178: 0x0001, // Block 0x46, offset 0x1180 0x1180: 0x0001, 0x1181: 0x0001, 0x1182: 0x0001, 0x1183: 0x0001, 0x1184: 0x0001, 0x1185: 0x0001, 0x1186: 0x0001, 0x1187: 0x0001, 0x1188: 0x0001, 0x1189: 0x0001, 0x118a: 0x0001, 0x118b: 0x0001, 0x118c: 0x0001, 0x118d: 0x0001, 0x118e: 0x0001, 0x118f: 0x0001, 0x1190: 0x0001, 0x1191: 0x0001, 0x1192: 0x0008, 0x1193: 0x0008, 0x1194: 0x0008, 0x1195: 0x0008, 0x119f: 0x0001, 0x11a0: 0x0001, 0x11a1: 0x0001, 0x11a2: 0x0001, 0x11a3: 0x0001, 0x11a4: 0x0001, 0x11a5: 0x0001, 0x11a6: 0x0001, 0x11a7: 0x0001, 0x11a8: 0x0001, 0x11a9: 0x0001, 0x11aa: 0x0001, 0x11ab: 0x0001, 0x11ac: 0x0001, 0x11ad: 0x0001, 0x11ae: 0x0001, 0x11af: 0x0001, 0x11b0: 0x0001, 0x11b1: 0x0001, 0x11b2: 0x0008, 0x11b3: 0x0008, 0x11b4: 0x0008, // Block 0x47, offset 0x11c0 0x11c0: 0x0001, 0x11c1: 0x0001, 0x11c2: 0x0001, 0x11c3: 0x0001, 0x11c4: 0x0001, 0x11c5: 0x0001, 0x11c6: 0x0001, 0x11c7: 0x0001, 0x11c8: 0x0001, 0x11c9: 0x0001, 0x11ca: 0x0001, 0x11cb: 0x0001, 0x11cc: 0x0001, 0x11cd: 0x0001, 0x11ce: 0x0001, 0x11cf: 0x0001, 0x11d0: 0x0001, 0x11d1: 0x0001, 0x11d2: 0x0008, 0x11d3: 0x0008, 0x11e0: 0x0001, 0x11e1: 0x0001, 0x11e2: 0x0001, 0x11e3: 0x0001, 0x11e4: 0x0001, 0x11e5: 0x0001, 0x11e6: 0x0001, 0x11e7: 0x0001, 0x11e8: 0x0001, 0x11e9: 0x0001, 0x11ea: 0x0001, 0x11eb: 0x0001, 0x11ec: 0x0001, 0x11ee: 0x0001, 0x11ef: 0x0001, 0x11f0: 0x0001, 0x11f2: 0x0008, 0x11f3: 0x0008, // Block 0x48, offset 0x1200 0x1234: 0x0008, 0x1235: 0x0008, 0x1236: 0x0008, 0x1237: 0x0008, 0x1238: 0x0008, 0x1239: 0x0008, 0x123a: 0x0008, 0x123b: 0x0008, 0x123c: 0x0008, 0x123d: 0x0008, 0x123e: 0x0008, 0x123f: 0x0008, // Block 0x49, offset 0x1240 0x1240: 0x0008, 0x1241: 0x0008, 0x1242: 0x0008, 0x1243: 0x0008, 0x1244: 0x0008, 0x1245: 0x0008, 0x1246: 0x0008, 0x1247: 0x0008, 0x1248: 0x0008, 0x1249: 0x0008, 0x124a: 0x0008, 0x124b: 0x0008, 0x124c: 0x0008, 0x124d: 0x0008, 0x124e: 0x0008, 0x124f: 0x0008, 0x1250: 0x0008, 0x1251: 0x0008, 0x1252: 0x0008, 0x1253: 0x0008, 0x125d: 0x0008, 0x1260: 0x4000, 0x1261: 0x4000, 0x1262: 0x4000, 0x1263: 0x4000, 0x1264: 0x4000, 0x1265: 0x4000, 0x1266: 0x4000, 0x1267: 0x4000, 0x1268: 0x4000, 0x1269: 0x4000, // Block 0x4a, offset 0x1280 0x128b: 0x0008, 0x128c: 0x0008, 0x128d: 0x0008, 0x128e: 0x0040, 0x128f: 0x0008, 0x1290: 0x4000, 0x1291: 0x4000, 0x1292: 0x4000, 0x1293: 0x4000, 0x1294: 0x4000, 0x1295: 0x4000, 0x1296: 0x4000, 0x1297: 0x4000, 0x1298: 0x4000, 0x1299: 0x4000, 0x12a0: 0x0001, 0x12a1: 0x0001, 0x12a2: 0x0001, 0x12a3: 0x0001, 0x12a4: 0x0001, 0x12a5: 0x0001, 0x12a6: 0x0001, 0x12a7: 0x0001, 0x12a8: 0x0001, 0x12a9: 0x0001, 0x12aa: 0x0001, 0x12ab: 0x0001, 0x12ac: 0x0001, 0x12ad: 0x0001, 0x12ae: 0x0001, 0x12af: 0x0001, 0x12b0: 0x0001, 0x12b1: 0x0001, 0x12b2: 0x0001, 0x12b3: 0x0001, 0x12b4: 0x0001, 0x12b5: 0x0001, 0x12b6: 0x0001, 0x12b7: 0x0001, 0x12b8: 0x0001, 0x12b9: 0x0001, 0x12ba: 0x0001, 0x12bb: 0x0001, 0x12bc: 0x0001, 0x12bd: 0x0001, 0x12be: 0x0001, 0x12bf: 0x0001, // Block 0x4b, offset 0x12c0 0x12c0: 0x0001, 0x12c1: 0x0001, 0x12c2: 0x0001, 0x12c3: 0x0001, 0x12c4: 0x0001, 0x12c5: 0x0001, 0x12c6: 0x0001, 0x12c7: 0x0001, 0x12c8: 0x0001, 0x12c9: 0x0001, 0x12ca: 0x0001, 0x12cb: 0x0001, 0x12cc: 0x0001, 0x12cd: 0x0001, 0x12ce: 0x0001, 0x12cf: 0x0001, 0x12d0: 0x0001, 0x12d1: 0x0001, 0x12d2: 0x0001, 0x12d3: 0x0001, 0x12d4: 0x0001, 0x12d5: 0x0001, 0x12d6: 0x0001, 0x12d7: 0x0001, 0x12d8: 0x0001, 0x12d9: 0x0001, 0x12da: 0x0001, 0x12db: 0x0001, 0x12dc: 0x0001, 0x12dd: 0x0001, 0x12de: 0x0001, 0x12df: 0x0001, 0x12e0: 0x0001, 0x12e1: 0x0001, 0x12e2: 0x0001, 0x12e3: 0x0001, 0x12e4: 0x0001, 0x12e5: 0x0001, 0x12e6: 0x0001, 0x12e7: 0x0001, 0x12e8: 0x0001, 0x12e9: 0x0001, 0x12ea: 0x0001, 0x12eb: 0x0001, 0x12ec: 0x0001, 0x12ed: 0x0001, 0x12ee: 0x0001, 0x12ef: 0x0001, 0x12f0: 0x0001, 0x12f1: 0x0001, 0x12f2: 0x0001, 0x12f3: 0x0001, 0x12f4: 0x0001, 0x12f5: 0x0001, 0x12f6: 0x0001, 0x12f7: 0x0001, 0x12f8: 0x0001, // Block 0x4c, offset 0x1300 0x1300: 0x0001, 0x1301: 0x0001, 0x1302: 0x0001, 0x1303: 0x0001, 0x1304: 0x0001, 0x1305: 0x0008, 0x1306: 0x0008, 0x1307: 0x0001, 0x1308: 0x0001, 0x1309: 0x0001, 0x130a: 0x0001, 0x130b: 0x0001, 0x130c: 0x0001, 0x130d: 0x0001, 0x130e: 0x0001, 0x130f: 0x0001, 0x1310: 0x0001, 0x1311: 0x0001, 0x1312: 0x0001, 0x1313: 0x0001, 0x1314: 0x0001, 0x1315: 0x0001, 0x1316: 0x0001, 0x1317: 0x0001, 0x1318: 0x0001, 0x1319: 0x0001, 0x131a: 0x0001, 0x131b: 0x0001, 0x131c: 0x0001, 0x131d: 0x0001, 0x131e: 0x0001, 0x131f: 0x0001, 0x1320: 0x0001, 0x1321: 0x0001, 0x1322: 0x0001, 0x1323: 0x0001, 0x1324: 0x0001, 0x1325: 0x0001, 0x1326: 0x0001, 0x1327: 0x0001, 0x1328: 0x0001, 0x1329: 0x0008, 0x132a: 0x0001, 0x1330: 0x0001, 0x1331: 0x0001, 0x1332: 0x0001, 0x1333: 0x0001, 0x1334: 0x0001, 0x1335: 0x0001, 0x1336: 0x0001, 0x1337: 0x0001, 0x1338: 0x0001, 0x1339: 0x0001, 0x133a: 0x0001, 0x133b: 0x0001, 0x133c: 0x0001, 0x133d: 0x0001, 0x133e: 0x0001, 0x133f: 0x0001, // Block 0x4d, offset 0x1340 0x1340: 0x0001, 0x1341: 0x0001, 0x1342: 0x0001, 0x1343: 0x0001, 0x1344: 0x0001, 0x1345: 0x0001, 0x1346: 0x0001, 0x1347: 0x0001, 0x1348: 0x0001, 0x1349: 0x0001, 0x134a: 0x0001, 0x134b: 0x0001, 0x134c: 0x0001, 0x134d: 0x0001, 0x134e: 0x0001, 0x134f: 0x0001, 0x1350: 0x0001, 0x1351: 0x0001, 0x1352: 0x0001, 0x1353: 0x0001, 0x1354: 0x0001, 0x1355: 0x0001, 0x1356: 0x0001, 0x1357: 0x0001, 0x1358: 0x0001, 0x1359: 0x0001, 0x135a: 0x0001, 0x135b: 0x0001, 0x135c: 0x0001, 0x135d: 0x0001, 0x135e: 0x0001, 0x135f: 0x0001, 0x1360: 0x0001, 0x1361: 0x0001, 0x1362: 0x0001, 0x1363: 0x0001, 0x1364: 0x0001, 0x1365: 0x0001, 0x1366: 0x0001, 0x1367: 0x0001, 0x1368: 0x0001, 0x1369: 0x0001, 0x136a: 0x0001, 0x136b: 0x0001, 0x136c: 0x0001, 0x136d: 0x0001, 0x136e: 0x0001, 0x136f: 0x0001, 0x1370: 0x0001, 0x1371: 0x0001, 0x1372: 0x0001, 0x1373: 0x0001, 0x1374: 0x0001, 0x1375: 0x0001, // Block 0x4e, offset 0x1380 0x1380: 0x0001, 0x1381: 0x0001, 0x1382: 0x0001, 0x1383: 0x0001, 0x1384: 0x0001, 0x1385: 0x0001, 0x1386: 0x0001, 0x1387: 0x0001, 0x1388: 0x0001, 0x1389: 0x0001, 0x138a: 0x0001, 0x138b: 0x0001, 0x138c: 0x0001, 0x138d: 0x0001, 0x138e: 0x0001, 0x138f: 0x0001, 0x1390: 0x0001, 0x1391: 0x0001, 0x1392: 0x0001, 0x1393: 0x0001, 0x1394: 0x0001, 0x1395: 0x0001, 0x1396: 0x0001, 0x1397: 0x0001, 0x1398: 0x0001, 0x1399: 0x0001, 0x139a: 0x0001, 0x139b: 0x0001, 0x139c: 0x0001, 0x139d: 0x0001, 0x139e: 0x0001, 0x13a0: 0x0008, 0x13a1: 0x0008, 0x13a2: 0x0008, 0x13a3: 0x0008, 0x13a4: 0x0008, 0x13a5: 0x0008, 0x13a6: 0x0008, 0x13a7: 0x0008, 0x13a8: 0x0008, 0x13a9: 0x0008, 0x13aa: 0x0008, 0x13ab: 0x0008, 0x13b0: 0x0008, 0x13b1: 0x0008, 0x13b2: 0x0008, 0x13b3: 0x0008, 0x13b4: 0x0008, 0x13b5: 0x0008, 0x13b6: 0x0008, 0x13b7: 0x0008, 0x13b8: 0x0008, 0x13b9: 0x0008, 0x13ba: 0x0008, 0x13bb: 0x0008, // Block 0x4f, offset 0x13c0 0x13c6: 0x4000, 0x13c7: 0x4000, 0x13c8: 0x4000, 0x13c9: 0x4000, 0x13ca: 0x4000, 0x13cb: 0x4000, 0x13cc: 0x4000, 0x13cd: 0x4000, 0x13ce: 0x4000, 0x13cf: 0x4000, // Block 0x50, offset 0x1400 0x1410: 0x4000, 0x1411: 0x4000, 0x1412: 0x4000, 0x1413: 0x4000, 0x1414: 0x4000, 0x1415: 0x4000, 0x1416: 0x4000, 0x1417: 0x4000, 0x1418: 0x4000, 0x1419: 0x4000, 0x141a: 0x4000, // Block 0x51, offset 0x1440 0x1440: 0x0001, 0x1441: 0x0001, 0x1442: 0x0001, 0x1443: 0x0001, 0x1444: 0x0001, 0x1445: 0x0001, 0x1446: 0x0001, 0x1447: 0x0001, 0x1448: 0x0001, 0x1449: 0x0001, 0x144a: 0x0001, 0x144b: 0x0001, 0x144c: 0x0001, 0x144d: 0x0001, 0x144e: 0x0001, 0x144f: 0x0001, 0x1450: 0x0001, 0x1451: 0x0001, 0x1452: 0x0001, 0x1453: 0x0001, 0x1454: 0x0001, 0x1455: 0x0001, 0x1456: 0x0001, 0x1457: 0x0008, 0x1458: 0x0008, 0x1459: 0x0008, 0x145a: 0x0008, 0x145b: 0x0008, // Block 0x52, offset 0x1480 0x1495: 0x0008, 0x1496: 0x0008, 0x1497: 0x0008, 0x1498: 0x0008, 0x1499: 0x0008, 0x149a: 0x0008, 0x149b: 0x0008, 0x149c: 0x0008, 0x149d: 0x0008, 0x149e: 0x0008, 0x14a0: 0x0008, 0x14a1: 0x0008, 0x14a2: 0x0008, 0x14a3: 0x0008, 0x14a4: 0x0008, 0x14a5: 0x0008, 0x14a6: 0x0008, 0x14a7: 0x0008, 0x14a8: 0x0008, 0x14a9: 0x0008, 0x14aa: 0x0008, 0x14ab: 0x0008, 0x14ac: 0x0008, 0x14ad: 0x0008, 0x14ae: 0x0008, 0x14af: 0x0008, 0x14b0: 0x0008, 0x14b1: 0x0008, 0x14b2: 0x0008, 0x14b3: 0x0008, 0x14b4: 0x0008, 0x14b5: 0x0008, 0x14b6: 0x0008, 0x14b7: 0x0008, 0x14b8: 0x0008, 0x14b9: 0x0008, 0x14ba: 0x0008, 0x14bb: 0x0008, 0x14bc: 0x0008, 0x14bf: 0x0008, // Block 0x53, offset 0x14c0 0x14c0: 0x4000, 0x14c1: 0x4000, 0x14c2: 0x4000, 0x14c3: 0x4000, 0x14c4: 0x4000, 0x14c5: 0x4000, 0x14c6: 0x4000, 0x14c7: 0x4000, 0x14c8: 0x4000, 0x14c9: 0x4000, 0x14d0: 0x4000, 0x14d1: 0x4000, 0x14d2: 0x4000, 0x14d3: 0x4000, 0x14d4: 0x4000, 0x14d5: 0x4000, 0x14d6: 0x4000, 0x14d7: 0x4000, 0x14d8: 0x4000, 0x14d9: 0x4000, 0x14f0: 0x0008, 0x14f1: 0x0008, 0x14f2: 0x0008, 0x14f3: 0x0008, 0x14f4: 0x0008, 0x14f5: 0x0008, 0x14f6: 0x0008, 0x14f7: 0x0008, 0x14f8: 0x0008, 0x14f9: 0x0008, 0x14fa: 0x0008, 0x14fb: 0x0008, 0x14fc: 0x0008, 0x14fd: 0x0008, 0x14fe: 0x0008, 0x14ff: 0x0008, // Block 0x54, offset 0x1500 0x1500: 0x0008, 0x1501: 0x0008, 0x1502: 0x0008, 0x1503: 0x0008, 0x1504: 0x0008, 0x1505: 0x0008, 0x1506: 0x0008, 0x1507: 0x0008, 0x1508: 0x0008, 0x1509: 0x0008, 0x150a: 0x0008, 0x150b: 0x0008, 0x150c: 0x0008, 0x150d: 0x0008, 0x150e: 0x0008, 0x150f: 0x0008, 0x1510: 0x0008, 0x1511: 0x0008, 0x1512: 0x0008, 0x1513: 0x0008, 0x1514: 0x0008, 0x1515: 0x0008, 0x1516: 0x0008, 0x1517: 0x0008, 0x1518: 0x0008, 0x1519: 0x0008, 0x151a: 0x0008, 0x151b: 0x0008, 0x151c: 0x0008, 0x151d: 0x0008, 0x1520: 0x0008, 0x1521: 0x0008, 0x1522: 0x0008, 0x1523: 0x0008, 0x1524: 0x0008, 0x1525: 0x0008, 0x1526: 0x0008, 0x1527: 0x0008, 0x1528: 0x0008, 0x1529: 0x0008, 0x152a: 0x0008, 0x152b: 0x0008, // Block 0x55, offset 0x1540 0x1540: 0x0008, 0x1541: 0x0008, 0x1542: 0x0008, 0x1543: 0x0008, 0x1544: 0x0008, 0x1545: 0x0001, 0x1546: 0x0001, 0x1547: 0x0001, 0x1548: 0x0001, 0x1549: 0x0001, 0x154a: 0x0001, 0x154b: 0x0001, 0x154c: 0x0001, 0x154d: 0x0001, 0x154e: 0x0001, 0x154f: 0x0001, 0x1550: 0x0001, 0x1551: 0x0001, 0x1552: 0x0001, 0x1553: 0x0001, 0x1554: 0x0001, 0x1555: 0x0001, 0x1556: 0x0001, 0x1557: 0x0001, 0x1558: 0x0001, 0x1559: 0x0001, 0x155a: 0x0001, 0x155b: 0x0001, 0x155c: 0x0001, 0x155d: 0x0001, 0x155e: 0x0001, 0x155f: 0x0001, 0x1560: 0x0001, 0x1561: 0x0001, 0x1562: 0x0001, 0x1563: 0x0001, 0x1564: 0x0001, 0x1565: 0x0001, 0x1566: 0x0001, 0x1567: 0x0001, 0x1568: 0x0001, 0x1569: 0x0001, 0x156a: 0x0001, 0x156b: 0x0001, 0x156c: 0x0001, 0x156d: 0x0001, 0x156e: 0x0001, 0x156f: 0x0001, 0x1570: 0x0001, 0x1571: 0x0001, 0x1572: 0x0001, 0x1573: 0x0001, 0x1574: 0x0008, 0x1575: 0x0008, 0x1576: 0x0008, 0x1577: 0x0008, 0x1578: 0x0008, 0x1579: 0x0008, 0x157a: 0x0008, 0x157b: 0x0008, 0x157c: 0x0008, 0x157d: 0x0008, 0x157e: 0x0008, 0x157f: 0x0008, // Block 0x56, offset 0x1580 0x1580: 0x0008, 0x1581: 0x0008, 0x1582: 0x0008, 0x1583: 0x0008, 0x1584: 0x0008, 0x1585: 0x0001, 0x1586: 0x0001, 0x1587: 0x0001, 0x1588: 0x0001, 0x1589: 0x0001, 0x158a: 0x0001, 0x158b: 0x0001, 0x158c: 0x0001, 0x1590: 0x4000, 0x1591: 0x4000, 0x1592: 0x4000, 0x1593: 0x4000, 0x1594: 0x4000, 0x1595: 0x4000, 0x1596: 0x4000, 0x1597: 0x4000, 0x1598: 0x4000, 0x1599: 0x4000, 0x15ab: 0x0008, 0x15ac: 0x0008, 0x15ad: 0x0008, 0x15ae: 0x0008, 0x15af: 0x0008, 0x15b0: 0x0008, 0x15b1: 0x0008, 0x15b2: 0x0008, 0x15b3: 0x0008, // Block 0x57, offset 0x15c0 0x15c0: 0x0008, 0x15c1: 0x0008, 0x15c2: 0x0008, 0x15c3: 0x0001, 0x15c4: 0x0001, 0x15c5: 0x0001, 0x15c6: 0x0001, 0x15c7: 0x0001, 0x15c8: 0x0001, 0x15c9: 0x0001, 0x15ca: 0x0001, 0x15cb: 0x0001, 0x15cc: 0x0001, 0x15cd: 0x0001, 0x15ce: 0x0001, 0x15cf: 0x0001, 0x15d0: 0x0001, 0x15d1: 0x0001, 0x15d2: 0x0001, 0x15d3: 0x0001, 0x15d4: 0x0001, 0x15d5: 0x0001, 0x15d6: 0x0001, 0x15d7: 0x0001, 0x15d8: 0x0001, 0x15d9: 0x0001, 0x15da: 0x0001, 0x15db: 0x0001, 0x15dc: 0x0001, 0x15dd: 0x0001, 0x15de: 0x0001, 0x15df: 0x0001, 0x15e0: 0x0001, 0x15e1: 0x0008, 0x15e2: 0x0008, 0x15e3: 0x0008, 0x15e4: 0x0008, 0x15e5: 0x0008, 0x15e6: 0x0008, 0x15e7: 0x0008, 0x15e8: 0x0008, 0x15e9: 0x0008, 0x15ea: 0x0008, 0x15eb: 0x0008, 0x15ec: 0x0008, 0x15ed: 0x0008, 0x15ee: 0x0001, 0x15ef: 0x0001, 0x15f0: 0x4000, 0x15f1: 0x4000, 0x15f2: 0x4000, 0x15f3: 0x4000, 0x15f4: 0x4000, 0x15f5: 0x4000, 0x15f6: 0x4000, 0x15f7: 0x4000, 0x15f8: 0x4000, 0x15f9: 0x4000, 0x15fa: 0x0001, 0x15fb: 0x0001, 0x15fc: 0x0001, 0x15fd: 0x0001, 0x15fe: 0x0001, 0x15ff: 0x0001, // Block 0x58, offset 0x1600 0x1600: 0x0001, 0x1601: 0x0001, 0x1602: 0x0001, 0x1603: 0x0001, 0x1604: 0x0001, 0x1605: 0x0001, 0x1606: 0x0001, 0x1607: 0x0001, 0x1608: 0x0001, 0x1609: 0x0001, 0x160a: 0x0001, 0x160b: 0x0001, 0x160c: 0x0001, 0x160d: 0x0001, 0x160e: 0x0001, 0x160f: 0x0001, 0x1610: 0x0001, 0x1611: 0x0001, 0x1612: 0x0001, 0x1613: 0x0001, 0x1614: 0x0001, 0x1615: 0x0001, 0x1616: 0x0001, 0x1617: 0x0001, 0x1618: 0x0001, 0x1619: 0x0001, 0x161a: 0x0001, 0x161b: 0x0001, 0x161c: 0x0001, 0x161d: 0x0001, 0x161e: 0x0001, 0x161f: 0x0001, 0x1620: 0x0001, 0x1621: 0x0001, 0x1622: 0x0001, 0x1623: 0x0001, 0x1624: 0x0001, 0x1625: 0x0001, 0x1626: 0x0008, 0x1627: 0x0008, 0x1628: 0x0008, 0x1629: 0x0008, 0x162a: 0x0008, 0x162b: 0x0008, 0x162c: 0x0008, 0x162d: 0x0008, 0x162e: 0x0008, 0x162f: 0x0008, 0x1630: 0x0008, 0x1631: 0x0008, 0x1632: 0x0008, 0x1633: 0x0008, // Block 0x59, offset 0x1640 0x1640: 0x0001, 0x1641: 0x0001, 0x1642: 0x0001, 0x1643: 0x0001, 0x1644: 0x0001, 0x1645: 0x0001, 0x1646: 0x0001, 0x1647: 0x0001, 0x1648: 0x0001, 0x1649: 0x0001, 0x164a: 0x0001, 0x164b: 0x0001, 0x164c: 0x0001, 0x164d: 0x0001, 0x164e: 0x0001, 0x164f: 0x0001, 0x1650: 0x0001, 0x1651: 0x0001, 0x1652: 0x0001, 0x1653: 0x0001, 0x1654: 0x0001, 0x1655: 0x0001, 0x1656: 0x0001, 0x1657: 0x0001, 0x1658: 0x0001, 0x1659: 0x0001, 0x165a: 0x0001, 0x165b: 0x0001, 0x165c: 0x0001, 0x165d: 0x0001, 0x165e: 0x0001, 0x165f: 0x0001, 0x1660: 0x0001, 0x1661: 0x0001, 0x1662: 0x0001, 0x1663: 0x0001, 0x1664: 0x0008, 0x1665: 0x0008, 0x1666: 0x0008, 0x1667: 0x0008, 0x1668: 0x0008, 0x1669: 0x0008, 0x166a: 0x0008, 0x166b: 0x0008, 0x166c: 0x0008, 0x166d: 0x0008, 0x166e: 0x0008, 0x166f: 0x0008, 0x1670: 0x0008, 0x1671: 0x0008, 0x1672: 0x0008, 0x1673: 0x0008, 0x1674: 0x0008, 0x1675: 0x0008, 0x1676: 0x0008, 0x1677: 0x0008, // Block 0x5a, offset 0x1680 0x1680: 0x4000, 0x1681: 0x4000, 0x1682: 0x4000, 0x1683: 0x4000, 0x1684: 0x4000, 0x1685: 0x4000, 0x1686: 0x4000, 0x1687: 0x4000, 0x1688: 0x4000, 0x1689: 0x4000, 0x168d: 0x0001, 0x168e: 0x0001, 0x168f: 0x0001, 0x1690: 0x4000, 0x1691: 0x4000, 0x1692: 0x4000, 0x1693: 0x4000, 0x1694: 0x4000, 0x1695: 0x4000, 0x1696: 0x4000, 0x1697: 0x4000, 0x1698: 0x4000, 0x1699: 0x4000, 0x169a: 0x0001, 0x169b: 0x0001, 0x169c: 0x0001, 0x169d: 0x0001, 0x169e: 0x0001, 0x169f: 0x0001, 0x16a0: 0x0001, 0x16a1: 0x0001, 0x16a2: 0x0001, 0x16a3: 0x0001, 0x16a4: 0x0001, 0x16a5: 0x0001, 0x16a6: 0x0001, 0x16a7: 0x0001, 0x16a8: 0x0001, 0x16a9: 0x0001, 0x16aa: 0x0001, 0x16ab: 0x0001, 0x16ac: 0x0001, 0x16ad: 0x0001, 0x16ae: 0x0001, 0x16af: 0x0001, 0x16b0: 0x0001, 0x16b1: 0x0001, 0x16b2: 0x0001, 0x16b3: 0x0001, 0x16b4: 0x0001, 0x16b5: 0x0001, 0x16b6: 0x0001, 0x16b7: 0x0001, 0x16b8: 0x0001, 0x16b9: 0x0001, 0x16ba: 0x0001, 0x16bb: 0x0001, 0x16bc: 0x0001, 0x16bd: 0x0001, // Block 0x5b, offset 0x16c0 0x16c0: 0x0001, 0x16c1: 0x0001, 0x16c2: 0x0001, 0x16c3: 0x0001, 0x16c4: 0x0001, 0x16c5: 0x0001, 0x16c6: 0x0001, 0x16c7: 0x0001, 0x16c8: 0x0001, 0x16c9: 0x0001, 0x16ca: 0x0001, 0x16d0: 0x0001, 0x16d1: 0x0001, 0x16d2: 0x0001, 0x16d3: 0x0001, 0x16d4: 0x0001, 0x16d5: 0x0001, 0x16d6: 0x0001, 0x16d7: 0x0001, 0x16d8: 0x0001, 0x16d9: 0x0001, 0x16da: 0x0001, 0x16db: 0x0001, 0x16dc: 0x0001, 0x16dd: 0x0001, 0x16de: 0x0001, 0x16df: 0x0001, 0x16e0: 0x0001, 0x16e1: 0x0001, 0x16e2: 0x0001, 0x16e3: 0x0001, 0x16e4: 0x0001, 0x16e5: 0x0001, 0x16e6: 0x0001, 0x16e7: 0x0001, 0x16e8: 0x0001, 0x16e9: 0x0001, 0x16ea: 0x0001, 0x16eb: 0x0001, 0x16ec: 0x0001, 0x16ed: 0x0001, 0x16ee: 0x0001, 0x16ef: 0x0001, 0x16f0: 0x0001, 0x16f1: 0x0001, 0x16f2: 0x0001, 0x16f3: 0x0001, 0x16f4: 0x0001, 0x16f5: 0x0001, 0x16f6: 0x0001, 0x16f7: 0x0001, 0x16f8: 0x0001, 0x16f9: 0x0001, 0x16fa: 0x0001, 0x16fd: 0x0001, 0x16fe: 0x0001, 0x16ff: 0x0001, // Block 0x5c, offset 0x1700 0x1710: 0x0008, 0x1711: 0x0008, 0x1712: 0x0008, 0x1714: 0x0008, 0x1715: 0x0008, 0x1716: 0x0008, 0x1717: 0x0008, 0x1718: 0x0008, 0x1719: 0x0008, 0x171a: 0x0008, 0x171b: 0x0008, 0x171c: 0x0008, 0x171d: 0x0008, 0x171e: 0x0008, 0x171f: 0x0008, 0x1720: 0x0008, 0x1721: 0x0008, 0x1722: 0x0008, 0x1723: 0x0008, 0x1724: 0x0008, 0x1725: 0x0008, 0x1726: 0x0008, 0x1727: 0x0008, 0x1728: 0x0008, 0x1729: 0x0001, 0x172a: 0x0001, 0x172b: 0x0001, 0x172c: 0x0001, 0x172d: 0x0008, 0x172e: 0x0001, 0x172f: 0x0001, 0x1730: 0x0001, 0x1731: 0x0001, 0x1732: 0x0001, 0x1733: 0x0001, 0x1734: 0x0008, 0x1735: 0x0001, 0x1736: 0x0001, 0x1737: 0x0008, 0x1738: 0x0008, 0x1739: 0x0008, 0x173a: 0x0001, // Block 0x5d, offset 0x1740 0x1740: 0x0001, 0x1741: 0x0001, 0x1742: 0x0001, 0x1743: 0x0001, 0x1744: 0x0001, 0x1745: 0x0001, 0x1746: 0x0001, 0x1747: 0x0001, 0x1748: 0x0001, 0x1749: 0x0001, 0x174a: 0x0001, 0x174b: 0x0001, 0x174c: 0x0001, 0x174d: 0x0001, 0x174e: 0x0001, 0x174f: 0x0001, 0x1750: 0x0001, 0x1751: 0x0001, 0x1752: 0x0001, 0x1753: 0x0001, 0x1754: 0x0001, 0x1755: 0x0001, 0x1758: 0x0001, 0x1759: 0x0001, 0x175a: 0x0001, 0x175b: 0x0001, 0x175c: 0x0001, 0x175d: 0x0001, 0x1760: 0x0001, 0x1761: 0x0001, 0x1762: 0x0001, 0x1763: 0x0001, 0x1764: 0x0001, 0x1765: 0x0001, 0x1766: 0x0001, 0x1767: 0x0001, 0x1768: 0x0001, 0x1769: 0x0001, 0x176a: 0x0001, 0x176b: 0x0001, 0x176c: 0x0001, 0x176d: 0x0001, 0x176e: 0x0001, 0x176f: 0x0001, 0x1770: 0x0001, 0x1771: 0x0001, 0x1772: 0x0001, 0x1773: 0x0001, 0x1774: 0x0001, 0x1775: 0x0001, 0x1776: 0x0001, 0x1777: 0x0001, 0x1778: 0x0001, 0x1779: 0x0001, 0x177a: 0x0001, 0x177b: 0x0001, 0x177c: 0x0001, 0x177d: 0x0001, 0x177e: 0x0001, 0x177f: 0x0001, // Block 0x5e, offset 0x1780 0x1780: 0x0001, 0x1781: 0x0001, 0x1782: 0x0001, 0x1783: 0x0001, 0x1784: 0x0001, 0x1785: 0x0001, 0x1788: 0x0001, 0x1789: 0x0001, 0x178a: 0x0001, 0x178b: 0x0001, 0x178c: 0x0001, 0x178d: 0x0001, 0x1790: 0x0001, 0x1791: 0x0001, 0x1792: 0x0001, 0x1793: 0x0001, 0x1794: 0x0001, 0x1795: 0x0001, 0x1796: 0x0001, 0x1797: 0x0001, 0x1799: 0x0001, 0x179b: 0x0001, 0x179d: 0x0001, 0x179f: 0x0001, 0x17a0: 0x0001, 0x17a1: 0x0001, 0x17a2: 0x0001, 0x17a3: 0x0001, 0x17a4: 0x0001, 0x17a5: 0x0001, 0x17a6: 0x0001, 0x17a7: 0x0001, 0x17a8: 0x0001, 0x17a9: 0x0001, 0x17aa: 0x0001, 0x17ab: 0x0001, 0x17ac: 0x0001, 0x17ad: 0x0001, 0x17ae: 0x0001, 0x17af: 0x0001, 0x17b0: 0x0001, 0x17b1: 0x0001, 0x17b2: 0x0001, 0x17b3: 0x0001, 0x17b4: 0x0001, 0x17b5: 0x0001, 0x17b6: 0x0001, 0x17b7: 0x0001, 0x17b8: 0x0001, 0x17b9: 0x0001, 0x17ba: 0x0001, 0x17bb: 0x0001, 0x17bc: 0x0001, 0x17bd: 0x0001, // Block 0x5f, offset 0x17c0 0x17c0: 0x0001, 0x17c1: 0x0001, 0x17c2: 0x0001, 0x17c3: 0x0001, 0x17c4: 0x0001, 0x17c5: 0x0001, 0x17c6: 0x0001, 0x17c7: 0x0001, 0x17c8: 0x0001, 0x17c9: 0x0001, 0x17ca: 0x0001, 0x17cb: 0x0001, 0x17cc: 0x0001, 0x17cd: 0x0001, 0x17ce: 0x0001, 0x17cf: 0x0001, 0x17d0: 0x0001, 0x17d1: 0x0001, 0x17d2: 0x0001, 0x17d3: 0x0001, 0x17d4: 0x0001, 0x17d5: 0x0001, 0x17d6: 0x0001, 0x17d7: 0x0001, 0x17d8: 0x0001, 0x17d9: 0x0001, 0x17da: 0x0001, 0x17db: 0x0001, 0x17dc: 0x0001, 0x17dd: 0x0001, 0x17de: 0x0001, 0x17df: 0x0001, 0x17e0: 0x0001, 0x17e1: 0x0001, 0x17e2: 0x0001, 0x17e3: 0x0001, 0x17e4: 0x0001, 0x17e5: 0x0001, 0x17e6: 0x0001, 0x17e7: 0x0001, 0x17e8: 0x0001, 0x17e9: 0x0001, 0x17ea: 0x0001, 0x17eb: 0x0001, 0x17ec: 0x0001, 0x17ed: 0x0001, 0x17ee: 0x0001, 0x17ef: 0x0001, 0x17f0: 0x0001, 0x17f1: 0x0001, 0x17f2: 0x0001, 0x17f3: 0x0001, 0x17f4: 0x0001, 0x17f6: 0x0001, 0x17f7: 0x0001, 0x17f8: 0x0001, 0x17f9: 0x0001, 0x17fa: 0x0001, 0x17fb: 0x0001, 0x17fc: 0x0001, 0x17fe: 0x0001, // Block 0x60, offset 0x1800 0x1802: 0x0001, 0x1803: 0x0001, 0x1804: 0x0001, 0x1806: 0x0001, 0x1807: 0x0001, 0x1808: 0x0001, 0x1809: 0x0001, 0x180a: 0x0001, 0x180b: 0x0001, 0x180c: 0x0001, 0x1810: 0x0001, 0x1811: 0x0001, 0x1812: 0x0001, 0x1813: 0x0001, 0x1816: 0x0001, 0x1817: 0x0001, 0x1818: 0x0001, 0x1819: 0x0001, 0x181a: 0x0001, 0x181b: 0x0001, 0x1820: 0x0001, 0x1821: 0x0001, 0x1822: 0x0001, 0x1823: 0x0001, 0x1824: 0x0001, 0x1825: 0x0001, 0x1826: 0x0001, 0x1827: 0x0001, 0x1828: 0x0001, 0x1829: 0x0001, 0x182a: 0x0001, 0x182b: 0x0001, 0x182c: 0x0001, 0x1832: 0x0001, 0x1833: 0x0001, 0x1834: 0x0001, 0x1836: 0x0001, 0x1837: 0x0001, 0x1838: 0x0001, 0x1839: 0x0001, 0x183a: 0x0001, 0x183b: 0x0001, 0x183c: 0x0001, // Block 0x61, offset 0x1840 0x1840: 0x20000, 0x1841: 0x20000, 0x1842: 0x20000, 0x1843: 0x20000, 0x1844: 0x20000, 0x1845: 0x20000, 0x1846: 0x20000, 0x1848: 0x20000, 0x1849: 0x20000, 0x184a: 0x20000, 0x184c: 0x0008, 0x184d: 0x40000, 0x184e: 0x0040, 0x184f: 0x0040, 0x1858: 0x1000, 0x1859: 0x1000, 0x1864: 0x1000, 0x1867: 0x0400, 0x1868: 0x2000, 0x1869: 0x2000, 0x186a: 0x0040, 0x186b: 0x0040, 0x186c: 0x0040, 0x186d: 0x0040, 0x186e: 0x0040, 0x186f: 0x0010, 0x187c: 0x0020, 0x187f: 0x0010, // Block 0x62, offset 0x1880 0x1880: 0x0010, 0x1884: 0x0800, 0x1889: 0x0020, 0x1894: 0x0010, 0x189f: 0x20000, 0x18a0: 0x0040, 0x18a1: 0x0040, 0x18a2: 0x0040, 0x18a3: 0x0040, 0x18a4: 0x0040, 0x18a6: 0x0040, 0x18a7: 0x0040, 0x18a8: 0x0040, 0x18a9: 0x0040, 0x18aa: 0x0040, 0x18ab: 0x0040, 0x18ac: 0x0040, 0x18ad: 0x0040, 0x18ae: 0x0040, 0x18af: 0x0040, 0x18b1: 0x0001, 0x18bf: 0x0001, // Block 0x63, offset 0x18c0 0x18d0: 0x0001, 0x18d1: 0x0001, 0x18d2: 0x0001, 0x18d3: 0x0001, 0x18d4: 0x0001, 0x18d5: 0x0001, 0x18d6: 0x0001, 0x18d7: 0x0001, 0x18d8: 0x0001, 0x18d9: 0x0001, 0x18da: 0x0001, 0x18db: 0x0001, 0x18dc: 0x0001, // Block 0x64, offset 0x1900 0x1910: 0x0008, 0x1911: 0x0008, 0x1912: 0x0008, 0x1913: 0x0008, 0x1914: 0x0008, 0x1915: 0x0008, 0x1916: 0x0008, 0x1917: 0x0008, 0x1918: 0x0008, 0x1919: 0x0008, 0x191a: 0x0008, 0x191b: 0x0008, 0x191c: 0x0008, 0x191d: 0x0008, 0x191e: 0x0008, 0x191f: 0x0008, 0x1920: 0x0008, 0x1921: 0x0008, 0x1922: 0x0008, 0x1923: 0x0008, 0x1924: 0x0008, 0x1925: 0x0008, 0x1926: 0x0008, 0x1927: 0x0008, 0x1928: 0x0008, 0x1929: 0x0008, 0x192a: 0x0008, 0x192b: 0x0008, 0x192c: 0x0008, 0x192d: 0x0008, 0x192e: 0x0008, 0x192f: 0x0008, 0x1930: 0x0008, // Block 0x65, offset 0x1940 0x1942: 0x0001, 0x1947: 0x0001, 0x194a: 0x0001, 0x194b: 0x0001, 0x194c: 0x0001, 0x194d: 0x0001, 0x194e: 0x0001, 0x194f: 0x0001, 0x1950: 0x0001, 0x1951: 0x0001, 0x1952: 0x0001, 0x1953: 0x0001, 0x1955: 0x0001, 0x1959: 0x0001, 0x195a: 0x0001, 0x195b: 0x0001, 0x195c: 0x0001, 0x195d: 0x0001, 0x1962: 0x0020, 0x1964: 0x0001, 0x1966: 0x0001, 0x1968: 0x0001, 0x196a: 0x0001, 0x196b: 0x0001, 0x196c: 0x0001, 0x196d: 0x0001, 0x196f: 0x0001, 0x1970: 0x0001, 0x1971: 0x0001, 0x1972: 0x0001, 0x1973: 0x0001, 0x1974: 0x0001, 0x1975: 0x0001, 0x1976: 0x0001, 0x1977: 0x0001, 0x1978: 0x0001, 0x1979: 0x0021, 0x197c: 0x0001, 0x197d: 0x0001, 0x197e: 0x0001, 0x197f: 0x0001, // Block 0x66, offset 0x1980 0x1985: 0x0001, 0x1986: 0x0001, 0x1987: 0x0001, 0x1988: 0x0001, 0x1989: 0x0001, 0x198e: 0x0001, 0x19a0: 0x0001, 0x19a1: 0x0001, 0x19a2: 0x0001, 0x19a3: 0x0001, 0x19a4: 0x0001, 0x19a5: 0x0001, 0x19a6: 0x0001, 0x19a7: 0x0001, 0x19a8: 0x0001, 0x19a9: 0x0001, 0x19aa: 0x0001, 0x19ab: 0x0001, 0x19ac: 0x0001, 0x19ad: 0x0001, 0x19ae: 0x0001, 0x19af: 0x0001, 0x19b0: 0x0001, 0x19b1: 0x0001, 0x19b2: 0x0001, 0x19b3: 0x0001, 0x19b4: 0x0001, 0x19b5: 0x0001, 0x19b6: 0x0001, 0x19b7: 0x0001, 0x19b8: 0x0001, 0x19b9: 0x0001, 0x19ba: 0x0001, 0x19bb: 0x0001, 0x19bc: 0x0001, 0x19bd: 0x0001, 0x19be: 0x0001, 0x19bf: 0x0001, // Block 0x67, offset 0x19c0 0x19c0: 0x0001, 0x19c1: 0x0001, 0x19c2: 0x0001, 0x19c3: 0x0001, 0x19c4: 0x0001, 0x19c5: 0x0001, 0x19c6: 0x0001, 0x19c7: 0x0001, 0x19c8: 0x0001, 0x19d4: 0x0020, 0x19d5: 0x0020, 0x19d6: 0x0020, 0x19d7: 0x0020, 0x19d8: 0x0020, 0x19d9: 0x0020, 0x19e9: 0x0020, 0x19ea: 0x0020, // Block 0x68, offset 0x1a00 0x1a1a: 0x0020, 0x1a1b: 0x0020, 0x1a28: 0x0020, // Block 0x69, offset 0x1a40 0x1a4f: 0x0020, 0x1a69: 0x0020, 0x1a6a: 0x0020, 0x1a6b: 0x0020, 0x1a6c: 0x0020, 0x1a6d: 0x0020, 0x1a6e: 0x0020, 0x1a6f: 0x0020, 0x1a70: 0x0020, 0x1a71: 0x0020, 0x1a72: 0x0020, 0x1a73: 0x0020, 0x1a78: 0x0020, 0x1a79: 0x0020, 0x1a7a: 0x0020, // Block 0x6a, offset 0x1a80 0x1ab6: 0x0001, 0x1ab7: 0x0001, 0x1ab8: 0x0001, 0x1ab9: 0x0001, 0x1aba: 0x0001, 0x1abb: 0x0001, 0x1abc: 0x0001, 0x1abd: 0x0001, 0x1abe: 0x0001, 0x1abf: 0x0001, // Block 0x6b, offset 0x1ac0 0x1ac0: 0x0001, 0x1ac1: 0x0001, 0x1ac2: 0x0021, 0x1ac3: 0x0001, 0x1ac4: 0x0001, 0x1ac5: 0x0001, 0x1ac6: 0x0001, 0x1ac7: 0x0001, 0x1ac8: 0x0001, 0x1ac9: 0x0001, 0x1aca: 0x0001, 0x1acb: 0x0001, 0x1acc: 0x0001, 0x1acd: 0x0001, 0x1ace: 0x0001, 0x1acf: 0x0001, 0x1ad0: 0x0001, 0x1ad1: 0x0001, 0x1ad2: 0x0001, 0x1ad3: 0x0001, 0x1ad4: 0x0001, 0x1ad5: 0x0001, 0x1ad6: 0x0001, 0x1ad7: 0x0001, 0x1ad8: 0x0001, 0x1ad9: 0x0001, 0x1ada: 0x0001, 0x1adb: 0x0001, 0x1adc: 0x0001, 0x1add: 0x0001, 0x1ade: 0x0001, 0x1adf: 0x0001, 0x1ae0: 0x0001, 0x1ae1: 0x0001, 0x1ae2: 0x0001, 0x1ae3: 0x0001, 0x1ae4: 0x0001, 0x1ae5: 0x0001, 0x1ae6: 0x0001, 0x1ae7: 0x0001, 0x1ae8: 0x0001, 0x1ae9: 0x0001, // Block 0x6c, offset 0x1b00 0x1b2a: 0x0020, 0x1b2b: 0x0020, 0x1b36: 0x0020, // Block 0x6d, offset 0x1b40 0x1b40: 0x0020, 0x1b7b: 0x0020, 0x1b7c: 0x0020, 0x1b7d: 0x0020, 0x1b7e: 0x0020, // Block 0x6e, offset 0x1b80 0x1b80: 0x0020, 0x1b81: 0x0020, 0x1b82: 0x0020, 0x1b83: 0x0020, 0x1b84: 0x0020, 0x1b8e: 0x0020, 0x1b91: 0x0020, 0x1b94: 0x0020, 0x1b95: 0x0020, 0x1b98: 0x0020, 0x1b9d: 0x0020, 0x1ba0: 0x0020, 0x1ba2: 0x0020, 0x1ba3: 0x0020, 0x1ba6: 0x0020, 0x1baa: 0x0020, 0x1bae: 0x0020, 0x1baf: 0x0020, 0x1bb8: 0x0020, 0x1bb9: 0x0020, 0x1bba: 0x0020, // Block 0x6f, offset 0x1bc0 0x1bc0: 0x0020, 0x1bc2: 0x0020, 0x1bc8: 0x0020, 0x1bc9: 0x0020, 0x1bca: 0x0020, 0x1bcb: 0x0020, 0x1bcc: 0x0020, 0x1bcd: 0x0020, 0x1bce: 0x0020, 0x1bcf: 0x0020, 0x1bd0: 0x0020, 0x1bd1: 0x0020, 0x1bd2: 0x0020, 0x1bd3: 0x0020, 0x1bdf: 0x0020, 0x1be0: 0x0020, 0x1be3: 0x0020, 0x1be5: 0x0020, 0x1be6: 0x0020, 0x1be8: 0x0020, 0x1bfb: 0x0020, 0x1bfe: 0x0020, 0x1bff: 0x0020, // Block 0x70, offset 0x1c00 0x1c12: 0x0020, 0x1c13: 0x0020, 0x1c14: 0x0020, 0x1c15: 0x0020, 0x1c16: 0x0020, 0x1c17: 0x0020, 0x1c19: 0x0020, 0x1c1b: 0x0020, 0x1c1c: 0x0020, 0x1c20: 0x0020, 0x1c21: 0x0020, 0x1c27: 0x0020, 0x1c2a: 0x0020, 0x1c2b: 0x0020, 0x1c30: 0x0020, 0x1c31: 0x0020, 0x1c3d: 0x0020, 0x1c3e: 0x0020, // Block 0x71, offset 0x1c40 0x1c44: 0x0020, 0x1c45: 0x0020, 0x1c48: 0x0020, 0x1c4e: 0x0020, 0x1c4f: 0x0020, 0x1c51: 0x0020, 0x1c53: 0x0020, 0x1c54: 0x0020, 0x1c69: 0x0020, 0x1c6a: 0x0020, 0x1c70: 0x0020, 0x1c71: 0x0020, 0x1c72: 0x0020, 0x1c73: 0x0020, 0x1c74: 0x0020, 0x1c75: 0x0020, 0x1c77: 0x0020, 0x1c78: 0x0020, 0x1c79: 0x0020, 0x1c7a: 0x0020, 0x1c7d: 0x0020, // Block 0x72, offset 0x1c80 0x1c82: 0x0020, 0x1c85: 0x0020, 0x1c88: 0x0020, 0x1c89: 0x0020, 0x1c8a: 0x0020, 0x1c8b: 0x0020, 0x1c8c: 0x0020, 0x1c8d: 0x0020, 0x1c8f: 0x0020, 0x1c92: 0x0020, 0x1c94: 0x0020, 0x1c96: 0x0020, 0x1c9d: 0x0020, 0x1ca1: 0x0020, 0x1ca8: 0x0020, 0x1cb3: 0x0020, 0x1cb4: 0x0020, // Block 0x73, offset 0x1cc0 0x1cc4: 0x0020, 0x1cc7: 0x0020, 0x1ccc: 0x0020, 0x1cce: 0x0020, 0x1cd3: 0x0020, 0x1cd4: 0x0020, 0x1cd5: 0x0020, 0x1cd7: 0x0020, 0x1ce3: 0x0020, 0x1ce4: 0x0020, // Block 0x74, offset 0x1d00 0x1d15: 0x0020, 0x1d16: 0x0020, 0x1d17: 0x0020, 0x1d21: 0x0020, 0x1d30: 0x0020, 0x1d3f: 0x0020, // Block 0x75, offset 0x1d40 0x1d74: 0x0020, 0x1d75: 0x0020, // Block 0x76, offset 0x1d80 0x1d85: 0x0020, 0x1d86: 0x0020, 0x1d87: 0x0020, 0x1d9b: 0x0020, 0x1d9c: 0x0020, // Block 0x77, offset 0x1dc0 0x1dd0: 0x0020, 0x1dd5: 0x0020, // Block 0x78, offset 0x1e00 0x1e00: 0x0001, 0x1e01: 0x0001, 0x1e02: 0x0001, 0x1e03: 0x0001, 0x1e04: 0x0001, 0x1e05: 0x0001, 0x1e06: 0x0001, 0x1e07: 0x0001, 0x1e08: 0x0001, 0x1e09: 0x0001, 0x1e0a: 0x0001, 0x1e0b: 0x0001, 0x1e0c: 0x0001, 0x1e0d: 0x0001, 0x1e0e: 0x0001, 0x1e0f: 0x0001, 0x1e10: 0x0001, 0x1e11: 0x0001, 0x1e12: 0x0001, 0x1e13: 0x0001, 0x1e14: 0x0001, 0x1e15: 0x0001, 0x1e16: 0x0001, 0x1e17: 0x0001, 0x1e18: 0x0001, 0x1e19: 0x0001, 0x1e1a: 0x0001, 0x1e1b: 0x0001, 0x1e1c: 0x0001, 0x1e1d: 0x0001, 0x1e1e: 0x0001, 0x1e1f: 0x0001, 0x1e20: 0x0001, 0x1e21: 0x0001, 0x1e22: 0x0001, 0x1e23: 0x0001, 0x1e24: 0x0001, 0x1e2b: 0x0001, 0x1e2c: 0x0001, 0x1e2d: 0x0001, 0x1e2e: 0x0001, 0x1e2f: 0x0008, 0x1e30: 0x0008, 0x1e31: 0x0008, 0x1e32: 0x0001, 0x1e33: 0x0001, // Block 0x79, offset 0x1e40 0x1e40: 0x0001, 0x1e41: 0x0001, 0x1e42: 0x0001, 0x1e43: 0x0001, 0x1e44: 0x0001, 0x1e45: 0x0001, 0x1e46: 0x0001, 0x1e47: 0x0001, 0x1e48: 0x0001, 0x1e49: 0x0001, 0x1e4a: 0x0001, 0x1e4b: 0x0001, 0x1e4c: 0x0001, 0x1e4d: 0x0001, 0x1e4e: 0x0001, 0x1e4f: 0x0001, 0x1e50: 0x0001, 0x1e51: 0x0001, 0x1e52: 0x0001, 0x1e53: 0x0001, 0x1e54: 0x0001, 0x1e55: 0x0001, 0x1e56: 0x0001, 0x1e57: 0x0001, 0x1e58: 0x0001, 0x1e59: 0x0001, 0x1e5a: 0x0001, 0x1e5b: 0x0001, 0x1e5c: 0x0001, 0x1e5d: 0x0001, 0x1e5e: 0x0001, 0x1e5f: 0x0001, 0x1e60: 0x0001, 0x1e61: 0x0001, 0x1e62: 0x0001, 0x1e63: 0x0001, 0x1e64: 0x0001, 0x1e65: 0x0001, 0x1e67: 0x0001, 0x1e6d: 0x0001, 0x1e70: 0x0001, 0x1e71: 0x0001, 0x1e72: 0x0001, 0x1e73: 0x0001, 0x1e74: 0x0001, 0x1e75: 0x0001, 0x1e76: 0x0001, 0x1e77: 0x0001, 0x1e78: 0x0001, 0x1e79: 0x0001, 0x1e7a: 0x0001, 0x1e7b: 0x0001, 0x1e7c: 0x0001, 0x1e7d: 0x0001, 0x1e7e: 0x0001, 0x1e7f: 0x0001, // Block 0x7a, offset 0x1e80 0x1e80: 0x0001, 0x1e81: 0x0001, 0x1e82: 0x0001, 0x1e83: 0x0001, 0x1e84: 0x0001, 0x1e85: 0x0001, 0x1e86: 0x0001, 0x1e87: 0x0001, 0x1e88: 0x0001, 0x1e89: 0x0001, 0x1e8a: 0x0001, 0x1e8b: 0x0001, 0x1e8c: 0x0001, 0x1e8d: 0x0001, 0x1e8e: 0x0001, 0x1e8f: 0x0001, 0x1e90: 0x0001, 0x1e91: 0x0001, 0x1e92: 0x0001, 0x1e93: 0x0001, 0x1e94: 0x0001, 0x1e95: 0x0001, 0x1e96: 0x0001, 0x1e97: 0x0001, 0x1e98: 0x0001, 0x1e99: 0x0001, 0x1e9a: 0x0001, 0x1e9b: 0x0001, 0x1e9c: 0x0001, 0x1e9d: 0x0001, 0x1e9e: 0x0001, 0x1e9f: 0x0001, 0x1ea0: 0x0001, 0x1ea1: 0x0001, 0x1ea2: 0x0001, 0x1ea3: 0x0001, 0x1ea4: 0x0001, 0x1ea5: 0x0001, 0x1ea6: 0x0001, 0x1ea7: 0x0001, 0x1eaf: 0x0001, 0x1ebf: 0x0008, // Block 0x7b, offset 0x1ec0 0x1ec0: 0x0001, 0x1ec1: 0x0001, 0x1ec2: 0x0001, 0x1ec3: 0x0001, 0x1ec4: 0x0001, 0x1ec5: 0x0001, 0x1ec6: 0x0001, 0x1ec7: 0x0001, 0x1ec8: 0x0001, 0x1ec9: 0x0001, 0x1eca: 0x0001, 0x1ecb: 0x0001, 0x1ecc: 0x0001, 0x1ecd: 0x0001, 0x1ece: 0x0001, 0x1ecf: 0x0001, 0x1ed0: 0x0001, 0x1ed1: 0x0001, 0x1ed2: 0x0001, 0x1ed3: 0x0001, 0x1ed4: 0x0001, 0x1ed5: 0x0001, 0x1ed6: 0x0001, 0x1ee0: 0x0001, 0x1ee1: 0x0001, 0x1ee2: 0x0001, 0x1ee3: 0x0001, 0x1ee4: 0x0001, 0x1ee5: 0x0001, 0x1ee6: 0x0001, 0x1ee8: 0x0001, 0x1ee9: 0x0001, 0x1eea: 0x0001, 0x1eeb: 0x0001, 0x1eec: 0x0001, 0x1eed: 0x0001, 0x1eee: 0x0001, 0x1ef0: 0x0001, 0x1ef1: 0x0001, 0x1ef2: 0x0001, 0x1ef3: 0x0001, 0x1ef4: 0x0001, 0x1ef5: 0x0001, 0x1ef6: 0x0001, 0x1ef8: 0x0001, 0x1ef9: 0x0001, 0x1efa: 0x0001, 0x1efb: 0x0001, 0x1efc: 0x0001, 0x1efd: 0x0001, 0x1efe: 0x0001, // Block 0x7c, offset 0x1f00 0x1f00: 0x0001, 0x1f01: 0x0001, 0x1f02: 0x0001, 0x1f03: 0x0001, 0x1f04: 0x0001, 0x1f05: 0x0001, 0x1f06: 0x0001, 0x1f08: 0x0001, 0x1f09: 0x0001, 0x1f0a: 0x0001, 0x1f0b: 0x0001, 0x1f0c: 0x0001, 0x1f0d: 0x0001, 0x1f0e: 0x0001, 0x1f10: 0x0001, 0x1f11: 0x0001, 0x1f12: 0x0001, 0x1f13: 0x0001, 0x1f14: 0x0001, 0x1f15: 0x0001, 0x1f16: 0x0001, 0x1f18: 0x0001, 0x1f19: 0x0001, 0x1f1a: 0x0001, 0x1f1b: 0x0001, 0x1f1c: 0x0001, 0x1f1d: 0x0001, 0x1f1e: 0x0001, 0x1f20: 0x0008, 0x1f21: 0x0008, 0x1f22: 0x0008, 0x1f23: 0x0008, 0x1f24: 0x0008, 0x1f25: 0x0008, 0x1f26: 0x0008, 0x1f27: 0x0008, 0x1f28: 0x0008, 0x1f29: 0x0008, 0x1f2a: 0x0008, 0x1f2b: 0x0008, 0x1f2c: 0x0008, 0x1f2d: 0x0008, 0x1f2e: 0x0008, 0x1f2f: 0x0008, 0x1f30: 0x0008, 0x1f31: 0x0008, 0x1f32: 0x0008, 0x1f33: 0x0008, 0x1f34: 0x0008, 0x1f35: 0x0008, 0x1f36: 0x0008, 0x1f37: 0x0008, 0x1f38: 0x0008, 0x1f39: 0x0008, 0x1f3a: 0x0008, 0x1f3b: 0x0008, 0x1f3c: 0x0008, 0x1f3d: 0x0008, 0x1f3e: 0x0008, 0x1f3f: 0x0008, // Block 0x7d, offset 0x1f40 0x1f6f: 0x0001, // Block 0x7e, offset 0x1f80 0x1f80: 0x20000, 0x1f85: 0x0001, 0x1faa: 0x0008, 0x1fab: 0x0008, 0x1fac: 0x0008, 0x1fad: 0x0008, 0x1fae: 0x0008, 0x1faf: 0x0008, 0x1fb0: 0x0020, 0x1fb1: 0x0100, 0x1fb2: 0x0100, 0x1fb3: 0x0100, 0x1fb4: 0x0100, 0x1fb5: 0x0100, 0x1fbb: 0x0001, 0x1fbc: 0x0001, 0x1fbd: 0x0020, // Block 0x7f, offset 0x1fc0 0x1fd9: 0x0008, 0x1fda: 0x0008, 0x1fdb: 0x0100, 0x1fdc: 0x0100, 0x1fe0: 0x0100, 0x1fe1: 0x0100, 0x1fe2: 0x0100, 0x1fe3: 0x0100, 0x1fe4: 0x0100, 0x1fe5: 0x0100, 0x1fe6: 0x0100, 0x1fe7: 0x0100, 0x1fe8: 0x0100, 0x1fe9: 0x0100, 0x1fea: 0x0100, 0x1feb: 0x0100, 0x1fec: 0x0100, 0x1fed: 0x0100, 0x1fee: 0x0100, 0x1fef: 0x0100, 0x1ff0: 0x0100, 0x1ff1: 0x0100, 0x1ff2: 0x0100, 0x1ff3: 0x0100, 0x1ff4: 0x0100, 0x1ff5: 0x0100, 0x1ff6: 0x0100, 0x1ff7: 0x0100, 0x1ff8: 0x0100, 0x1ff9: 0x0100, 0x1ffa: 0x0100, 0x1ffb: 0x0100, 0x1ffc: 0x0100, 0x1ffd: 0x0100, 0x1ffe: 0x0100, 0x1fff: 0x0100, // Block 0x80, offset 0x2000 0x2000: 0x0100, 0x2001: 0x0100, 0x2002: 0x0100, 0x2003: 0x0100, 0x2004: 0x0100, 0x2005: 0x0100, 0x2006: 0x0100, 0x2007: 0x0100, 0x2008: 0x0100, 0x2009: 0x0100, 0x200a: 0x0100, 0x200b: 0x0100, 0x200c: 0x0100, 0x200d: 0x0100, 0x200e: 0x0100, 0x200f: 0x0100, 0x2010: 0x0100, 0x2011: 0x0100, 0x2012: 0x0100, 0x2013: 0x0100, 0x2014: 0x0100, 0x2015: 0x0100, 0x2016: 0x0100, 0x2017: 0x0100, 0x2018: 0x0100, 0x2019: 0x0100, 0x201a: 0x0100, 0x201b: 0x0100, 0x201c: 0x0100, 0x201d: 0x0100, 0x201e: 0x0100, 0x201f: 0x0100, 0x2020: 0x0100, 0x2021: 0x0100, 0x2022: 0x0100, 0x2023: 0x0100, 0x2024: 0x0100, 0x2025: 0x0100, 0x2026: 0x0100, 0x2027: 0x0100, 0x2028: 0x0100, 0x2029: 0x0100, 0x202a: 0x0100, 0x202b: 0x0100, 0x202c: 0x0100, 0x202d: 0x0100, 0x202e: 0x0100, 0x202f: 0x0100, 0x2030: 0x0100, 0x2031: 0x0100, 0x2032: 0x0100, 0x2033: 0x0100, 0x2034: 0x0100, 0x2035: 0x0100, 0x2036: 0x0100, 0x2037: 0x0100, 0x2038: 0x0100, 0x2039: 0x0100, 0x203a: 0x0100, 0x203c: 0x0100, 0x203d: 0x0100, 0x203e: 0x0100, 0x203f: 0x0100, // Block 0x81, offset 0x2040 0x2045: 0x0001, 0x2046: 0x0001, 0x2047: 0x0001, 0x2048: 0x0001, 0x2049: 0x0001, 0x204a: 0x0001, 0x204b: 0x0001, 0x204c: 0x0001, 0x204d: 0x0001, 0x204e: 0x0001, 0x204f: 0x0001, 0x2050: 0x0001, 0x2051: 0x0001, 0x2052: 0x0001, 0x2053: 0x0001, 0x2054: 0x0001, 0x2055: 0x0001, 0x2056: 0x0001, 0x2057: 0x0001, 0x2058: 0x0001, 0x2059: 0x0001, 0x205a: 0x0001, 0x205b: 0x0001, 0x205c: 0x0001, 0x205d: 0x0001, 0x205e: 0x0001, 0x205f: 0x0001, 0x2060: 0x0001, 0x2061: 0x0001, 0x2062: 0x0001, 0x2063: 0x0001, 0x2064: 0x0001, 0x2065: 0x0001, 0x2066: 0x0001, 0x2067: 0x0001, 0x2068: 0x0001, 0x2069: 0x0001, 0x206a: 0x0001, 0x206b: 0x0001, 0x206c: 0x0001, 0x206d: 0x0001, 0x206e: 0x0001, 0x206f: 0x0001, 0x2071: 0x0001, 0x2072: 0x0001, 0x2073: 0x0001, 0x2074: 0x0001, 0x2075: 0x0001, 0x2076: 0x0001, 0x2077: 0x0001, 0x2078: 0x0001, 0x2079: 0x0001, 0x207a: 0x0001, 0x207b: 0x0001, 0x207c: 0x0001, 0x207d: 0x0001, 0x207e: 0x0001, 0x207f: 0x0001, // Block 0x82, offset 0x2080 0x2080: 0x0001, 0x2081: 0x0001, 0x2082: 0x0001, 0x2083: 0x0001, 0x2084: 0x0001, 0x2085: 0x0001, 0x2086: 0x0001, 0x2087: 0x0001, 0x2088: 0x0001, 0x2089: 0x0001, 0x208a: 0x0001, 0x208b: 0x0001, 0x208c: 0x0001, 0x208d: 0x0001, 0x208e: 0x0001, 0x20a0: 0x0001, 0x20a1: 0x0001, 0x20a2: 0x0001, 0x20a3: 0x0001, 0x20a4: 0x0001, 0x20a5: 0x0001, 0x20a6: 0x0001, 0x20a7: 0x0001, 0x20a8: 0x0001, 0x20a9: 0x0001, 0x20aa: 0x0001, 0x20ab: 0x0001, 0x20ac: 0x0001, 0x20ad: 0x0001, 0x20ae: 0x0001, 0x20af: 0x0001, 0x20b0: 0x0001, 0x20b1: 0x0001, 0x20b2: 0x0001, 0x20b3: 0x0001, 0x20b4: 0x0001, 0x20b5: 0x0001, 0x20b6: 0x0001, 0x20b7: 0x0001, 0x20b8: 0x0001, 0x20b9: 0x0001, 0x20ba: 0x0001, 0x20bb: 0x0001, 0x20bc: 0x0001, 0x20bd: 0x0001, 0x20be: 0x0001, 0x20bf: 0x0001, // Block 0x83, offset 0x20c0 0x20f0: 0x0100, 0x20f1: 0x0100, 0x20f2: 0x0100, 0x20f3: 0x0100, 0x20f4: 0x0100, 0x20f5: 0x0100, 0x20f6: 0x0100, 0x20f7: 0x0100, 0x20f8: 0x0100, 0x20f9: 0x0100, 0x20fa: 0x0100, 0x20fb: 0x0100, 0x20fc: 0x0100, 0x20fd: 0x0100, 0x20fe: 0x0100, 0x20ff: 0x0100, // Block 0x84, offset 0x2100 0x2117: 0x0020, 0x2119: 0x0020, // Block 0x85, offset 0x2140 0x2150: 0x0100, 0x2151: 0x0100, 0x2152: 0x0100, 0x2153: 0x0100, 0x2154: 0x0100, 0x2155: 0x0100, 0x2156: 0x0100, 0x2157: 0x0100, 0x2158: 0x0100, 0x2159: 0x0100, 0x215a: 0x0100, 0x215b: 0x0100, 0x215c: 0x0100, 0x215d: 0x0100, 0x215e: 0x0100, 0x215f: 0x0100, 0x2160: 0x0100, 0x2161: 0x0100, 0x2162: 0x0100, 0x2163: 0x0100, 0x2164: 0x0100, 0x2165: 0x0100, 0x2166: 0x0100, 0x2167: 0x0100, 0x2168: 0x0100, 0x2169: 0x0100, 0x216a: 0x0100, 0x216b: 0x0100, 0x216c: 0x0100, 0x216d: 0x0100, 0x216e: 0x0100, 0x216f: 0x0100, 0x2170: 0x0100, 0x2171: 0x0100, 0x2172: 0x0100, 0x2173: 0x0100, 0x2174: 0x0100, 0x2175: 0x0100, 0x2176: 0x0100, 0x2177: 0x0100, 0x2178: 0x0100, 0x2179: 0x0100, 0x217a: 0x0100, 0x217b: 0x0100, 0x217c: 0x0100, 0x217d: 0x0100, 0x217e: 0x0100, // Block 0x86, offset 0x2180 0x2180: 0x0100, 0x2181: 0x0100, 0x2182: 0x0100, 0x2183: 0x0100, 0x2184: 0x0100, 0x2185: 0x0100, 0x2186: 0x0100, 0x2187: 0x0100, 0x2188: 0x0100, 0x2189: 0x0100, 0x218a: 0x0100, 0x218b: 0x0100, 0x218c: 0x0100, 0x218d: 0x0100, 0x218e: 0x0100, 0x218f: 0x0100, 0x2190: 0x0100, 0x2191: 0x0100, 0x2192: 0x0100, 0x2193: 0x0100, 0x2194: 0x0100, 0x2195: 0x0100, 0x2196: 0x0100, 0x2197: 0x0100, 0x2198: 0x0100, 0x2199: 0x0100, 0x219a: 0x0100, 0x219b: 0x0100, 0x219c: 0x0100, 0x219d: 0x0100, 0x219e: 0x0100, 0x219f: 0x0100, 0x21a0: 0x0100, 0x21a1: 0x0100, 0x21a2: 0x0100, 0x21a3: 0x0100, 0x21a4: 0x0100, 0x21a5: 0x0100, 0x21a6: 0x0100, 0x21a7: 0x0100, 0x21a8: 0x0100, 0x21a9: 0x0100, 0x21aa: 0x0100, 0x21ab: 0x0100, 0x21ac: 0x0100, 0x21ad: 0x0100, 0x21ae: 0x0100, 0x21af: 0x0100, 0x21b0: 0x0100, 0x21b1: 0x0100, 0x21b2: 0x0100, 0x21b3: 0x0100, 0x21b4: 0x0100, 0x21b5: 0x0100, 0x21b6: 0x0100, 0x21b7: 0x0100, 0x21b8: 0x0100, 0x21b9: 0x0100, 0x21ba: 0x0100, 0x21bb: 0x0100, 0x21bc: 0x0100, 0x21bd: 0x0100, 0x21be: 0x0100, 0x21bf: 0x0100, // Block 0x87, offset 0x21c0 0x21c0: 0x0100, 0x21c1: 0x0100, 0x21c2: 0x0100, 0x21c3: 0x0100, 0x21c4: 0x0100, 0x21c5: 0x0100, 0x21c6: 0x0100, 0x21c7: 0x0100, 0x21c8: 0x0100, 0x21c9: 0x0100, 0x21ca: 0x0100, 0x21cb: 0x0100, 0x21cc: 0x0100, 0x21cd: 0x0100, 0x21ce: 0x0100, 0x21cf: 0x0100, 0x21d0: 0x0100, 0x21d1: 0x0100, 0x21d2: 0x0100, 0x21d3: 0x0100, 0x21d4: 0x0100, 0x21d5: 0x0100, 0x21d6: 0x0100, 0x21d7: 0x0100, // Block 0x88, offset 0x2200 0x2200: 0x0001, 0x2201: 0x0001, 0x2202: 0x0001, 0x2203: 0x0001, 0x2204: 0x0001, 0x2205: 0x0001, 0x2206: 0x0001, 0x2207: 0x0001, 0x2208: 0x0001, 0x2209: 0x0001, 0x220a: 0x0001, 0x220b: 0x0001, 0x220c: 0x0001, // Block 0x89, offset 0x2240 0x2250: 0x0001, 0x2251: 0x0001, 0x2252: 0x0001, 0x2253: 0x0001, 0x2254: 0x0001, 0x2255: 0x0001, 0x2256: 0x0001, 0x2257: 0x0001, 0x2258: 0x0001, 0x2259: 0x0001, 0x225a: 0x0001, 0x225b: 0x0001, 0x225c: 0x0001, 0x225d: 0x0001, 0x225e: 0x0001, 0x225f: 0x0001, 0x2260: 0x0001, 0x2261: 0x0001, 0x2262: 0x0001, 0x2263: 0x0001, 0x2264: 0x0001, 0x2265: 0x0001, 0x2266: 0x0001, 0x2267: 0x0001, 0x2268: 0x0001, 0x2269: 0x0001, 0x226a: 0x0001, 0x226b: 0x0001, 0x226c: 0x0001, 0x226d: 0x0001, 0x226e: 0x0001, 0x226f: 0x0001, 0x2270: 0x0001, 0x2271: 0x0001, 0x2272: 0x0001, 0x2273: 0x0001, 0x2274: 0x0001, 0x2275: 0x0001, 0x2276: 0x0001, 0x2277: 0x0001, 0x2278: 0x0001, 0x2279: 0x0001, 0x227a: 0x0001, 0x227b: 0x0001, 0x227c: 0x0001, 0x227d: 0x0001, // Block 0x8a, offset 0x2280 0x2280: 0x0001, 0x2281: 0x0001, 0x2282: 0x0001, 0x2283: 0x0001, 0x2284: 0x0001, 0x2285: 0x0001, 0x2286: 0x0001, 0x2287: 0x0001, 0x2288: 0x0001, 0x2289: 0x0001, 0x228a: 0x0001, 0x228b: 0x0001, 0x228c: 0x0001, 0x2290: 0x0001, 0x2291: 0x0001, 0x2292: 0x0001, 0x2293: 0x0001, 0x2294: 0x0001, 0x2295: 0x0001, 0x2296: 0x0001, 0x2297: 0x0001, 0x2298: 0x0001, 0x2299: 0x0001, 0x229a: 0x0001, 0x229b: 0x0001, 0x229c: 0x0001, 0x229d: 0x0001, 0x229e: 0x0001, 0x229f: 0x0001, 0x22a0: 0x4000, 0x22a1: 0x4000, 0x22a2: 0x4000, 0x22a3: 0x4000, 0x22a4: 0x4000, 0x22a5: 0x4000, 0x22a6: 0x4000, 0x22a7: 0x4000, 0x22a8: 0x4000, 0x22a9: 0x4000, 0x22aa: 0x0001, 0x22ab: 0x0001, // Block 0x8b, offset 0x22c0 0x22c0: 0x0001, 0x22c1: 0x0001, 0x22c2: 0x0001, 0x22c3: 0x0001, 0x22c4: 0x0001, 0x22c5: 0x0001, 0x22c6: 0x0001, 0x22c7: 0x0001, 0x22c8: 0x0001, 0x22c9: 0x0001, 0x22ca: 0x0001, 0x22cb: 0x0001, 0x22cc: 0x0001, 0x22cd: 0x0001, 0x22ce: 0x0001, 0x22cf: 0x0001, 0x22d0: 0x0001, 0x22d1: 0x0001, 0x22d2: 0x0001, 0x22d3: 0x0001, 0x22d4: 0x0001, 0x22d5: 0x0001, 0x22d6: 0x0001, 0x22d7: 0x0001, 0x22d8: 0x0001, 0x22d9: 0x0001, 0x22da: 0x0001, 0x22db: 0x0001, 0x22dc: 0x0001, 0x22dd: 0x0001, 0x22de: 0x0001, 0x22df: 0x0001, 0x22e0: 0x0001, 0x22e1: 0x0001, 0x22e2: 0x0001, 0x22e3: 0x0001, 0x22e4: 0x0001, 0x22e5: 0x0001, 0x22e6: 0x0001, 0x22e7: 0x0001, 0x22e8: 0x0001, 0x22e9: 0x0001, 0x22ea: 0x0001, 0x22eb: 0x0001, 0x22ec: 0x0001, 0x22ed: 0x0001, 0x22ee: 0x0001, 0x22ef: 0x0008, 0x22f0: 0x0008, 0x22f1: 0x0008, 0x22f2: 0x0008, 0x22f4: 0x0008, 0x22f5: 0x0008, 0x22f6: 0x0008, 0x22f7: 0x0008, 0x22f8: 0x0008, 0x22f9: 0x0008, 0x22fa: 0x0008, 0x22fb: 0x0008, 0x22fc: 0x0008, 0x22fd: 0x0008, 0x22ff: 0x0001, // Block 0x8c, offset 0x2300 0x2300: 0x0001, 0x2301: 0x0001, 0x2302: 0x0001, 0x2303: 0x0001, 0x2304: 0x0001, 0x2305: 0x0001, 0x2306: 0x0001, 0x2307: 0x0001, 0x2308: 0x0001, 0x2309: 0x0001, 0x230a: 0x0001, 0x230b: 0x0001, 0x230c: 0x0001, 0x230d: 0x0001, 0x230e: 0x0001, 0x230f: 0x0001, 0x2310: 0x0001, 0x2311: 0x0001, 0x2312: 0x0001, 0x2313: 0x0001, 0x2314: 0x0001, 0x2315: 0x0001, 0x2316: 0x0001, 0x2317: 0x0001, 0x2318: 0x0001, 0x2319: 0x0001, 0x231a: 0x0001, 0x231b: 0x0001, 0x231c: 0x0001, 0x231d: 0x0001, 0x231e: 0x0008, 0x231f: 0x0008, 0x2320: 0x0001, 0x2321: 0x0001, 0x2322: 0x0001, 0x2323: 0x0001, 0x2324: 0x0001, 0x2325: 0x0001, 0x2326: 0x0001, 0x2327: 0x0001, 0x2328: 0x0001, 0x2329: 0x0001, 0x232a: 0x0001, 0x232b: 0x0001, 0x232c: 0x0001, 0x232d: 0x0001, 0x232e: 0x0001, 0x232f: 0x0001, 0x2330: 0x0001, 0x2331: 0x0001, 0x2332: 0x0001, 0x2333: 0x0001, 0x2334: 0x0001, 0x2335: 0x0001, 0x2336: 0x0001, 0x2337: 0x0001, 0x2338: 0x0001, 0x2339: 0x0001, 0x233a: 0x0001, 0x233b: 0x0001, 0x233c: 0x0001, 0x233d: 0x0001, 0x233e: 0x0001, 0x233f: 0x0001, // Block 0x8d, offset 0x2340 0x2340: 0x0001, 0x2341: 0x0001, 0x2342: 0x0001, 0x2343: 0x0001, 0x2344: 0x0001, 0x2345: 0x0001, 0x2346: 0x0001, 0x2347: 0x0001, 0x2348: 0x0001, 0x2349: 0x0001, 0x234a: 0x0001, 0x234b: 0x0001, 0x234c: 0x0001, 0x234d: 0x0001, 0x234e: 0x0001, 0x234f: 0x0001, 0x2350: 0x0001, 0x2351: 0x0001, 0x2352: 0x0001, 0x2353: 0x0001, 0x2354: 0x0001, 0x2355: 0x0001, 0x2356: 0x0001, 0x2357: 0x0001, 0x2358: 0x0001, 0x2359: 0x0001, 0x235a: 0x0001, 0x235b: 0x0001, 0x235c: 0x0001, 0x235d: 0x0001, 0x235e: 0x0001, 0x235f: 0x0001, 0x2360: 0x0001, 0x2361: 0x0001, 0x2362: 0x0001, 0x2363: 0x0001, 0x2364: 0x0001, 0x2365: 0x0001, 0x2366: 0x0001, 0x2367: 0x0001, 0x2368: 0x0001, 0x2369: 0x0001, 0x236a: 0x0001, 0x236b: 0x0001, 0x236c: 0x0001, 0x236d: 0x0001, 0x236e: 0x0001, 0x236f: 0x0001, 0x2370: 0x0008, 0x2371: 0x0008, // Block 0x8e, offset 0x2380 0x2388: 0x0001, 0x2389: 0x0001, 0x238a: 0x0001, 0x238b: 0x0001, 0x238c: 0x0001, 0x238d: 0x0001, 0x238e: 0x0001, 0x238f: 0x0001, 0x2390: 0x0001, 0x2391: 0x0001, 0x2392: 0x0001, 0x2393: 0x0001, 0x2394: 0x0001, 0x2395: 0x0001, 0x2396: 0x0001, 0x2397: 0x0001, 0x2398: 0x0001, 0x2399: 0x0001, 0x239a: 0x0001, 0x239b: 0x0001, 0x239c: 0x0001, 0x239d: 0x0001, 0x239e: 0x0001, 0x239f: 0x0001, 0x23a0: 0x0001, 0x23a1: 0x0001, 0x23a2: 0x0001, 0x23a3: 0x0001, 0x23a4: 0x0001, 0x23a5: 0x0001, 0x23a6: 0x0001, 0x23a7: 0x0001, 0x23a8: 0x0001, 0x23a9: 0x0001, 0x23aa: 0x0001, 0x23ab: 0x0001, 0x23ac: 0x0001, 0x23ad: 0x0001, 0x23ae: 0x0001, 0x23af: 0x0001, 0x23b0: 0x0001, 0x23b1: 0x0001, 0x23b2: 0x0001, 0x23b3: 0x0001, 0x23b4: 0x0001, 0x23b5: 0x0001, 0x23b6: 0x0001, 0x23b7: 0x0001, 0x23b8: 0x0001, 0x23b9: 0x0001, 0x23ba: 0x0001, 0x23bb: 0x0001, 0x23bc: 0x0001, 0x23bd: 0x0001, 0x23be: 0x0001, 0x23bf: 0x0001, // Block 0x8f, offset 0x23c0 0x23c0: 0x0001, 0x23c1: 0x0001, 0x23c2: 0x0001, 0x23c3: 0x0001, 0x23c4: 0x0001, 0x23c5: 0x0001, 0x23c6: 0x0001, 0x23c7: 0x0001, 0x23c8: 0x0001, 0x23c9: 0x0001, 0x23ca: 0x0001, 0x23cb: 0x0001, 0x23cc: 0x0001, 0x23cd: 0x0001, 0x23ce: 0x0001, 0x23cf: 0x0001, 0x23d0: 0x0001, 0x23d1: 0x0001, 0x23d2: 0x0001, 0x23d3: 0x0001, 0x23d4: 0x0001, 0x23d5: 0x0001, 0x23d6: 0x0001, 0x23d7: 0x0001, 0x23d8: 0x0001, 0x23d9: 0x0001, 0x23da: 0x0001, 0x23db: 0x0001, 0x23dc: 0x0001, 0x23f1: 0x0001, 0x23f2: 0x0001, 0x23f3: 0x0001, 0x23f4: 0x0001, 0x23f5: 0x0001, 0x23f6: 0x0001, 0x23f7: 0x0001, 0x23f8: 0x0001, 0x23f9: 0x0001, 0x23fa: 0x0001, 0x23fb: 0x0001, 0x23fc: 0x0001, 0x23fd: 0x0001, 0x23fe: 0x0001, 0x23ff: 0x0001, // Block 0x90, offset 0x2400 0x2400: 0x0001, 0x2401: 0x0001, 0x2402: 0x0008, 0x2403: 0x0001, 0x2404: 0x0001, 0x2405: 0x0001, 0x2406: 0x0008, 0x2407: 0x0001, 0x2408: 0x0001, 0x2409: 0x0001, 0x240a: 0x0001, 0x240b: 0x0008, 0x240c: 0x0001, 0x240d: 0x0001, 0x240e: 0x0001, 0x240f: 0x0001, 0x2410: 0x0001, 0x2411: 0x0001, 0x2412: 0x0001, 0x2413: 0x0001, 0x2414: 0x0001, 0x2415: 0x0001, 0x2416: 0x0001, 0x2417: 0x0001, 0x2418: 0x0001, 0x2419: 0x0001, 0x241a: 0x0001, 0x241b: 0x0001, 0x241c: 0x0001, 0x241d: 0x0001, 0x241e: 0x0001, 0x241f: 0x0001, 0x2420: 0x0001, 0x2421: 0x0001, 0x2422: 0x0001, 0x2423: 0x0008, 0x2424: 0x0008, 0x2425: 0x0008, 0x2426: 0x0008, 0x2427: 0x0008, 0x242c: 0x0008, // Block 0x91, offset 0x2440 0x2440: 0x0001, 0x2441: 0x0001, 0x2442: 0x0001, 0x2443: 0x0001, 0x2444: 0x0001, 0x2445: 0x0001, 0x2446: 0x0001, 0x2447: 0x0001, 0x2448: 0x0001, 0x2449: 0x0001, 0x244a: 0x0001, 0x244b: 0x0001, 0x244c: 0x0001, 0x244d: 0x0001, 0x244e: 0x0001, 0x244f: 0x0001, 0x2450: 0x0001, 0x2451: 0x0001, 0x2452: 0x0001, 0x2453: 0x0001, 0x2454: 0x0001, 0x2455: 0x0001, 0x2456: 0x0001, 0x2457: 0x0001, 0x2458: 0x0001, 0x2459: 0x0001, 0x245a: 0x0001, 0x245b: 0x0001, 0x245c: 0x0001, 0x245d: 0x0001, 0x245e: 0x0001, 0x245f: 0x0001, 0x2460: 0x0001, 0x2461: 0x0001, 0x2462: 0x0001, 0x2463: 0x0001, 0x2464: 0x0001, 0x2465: 0x0001, 0x2466: 0x0001, 0x2467: 0x0001, 0x2468: 0x0001, 0x2469: 0x0001, 0x246a: 0x0001, 0x246b: 0x0001, 0x246c: 0x0001, 0x246d: 0x0001, 0x246e: 0x0001, 0x246f: 0x0001, 0x2470: 0x0001, 0x2471: 0x0001, 0x2472: 0x0001, 0x2473: 0x0001, // Block 0x92, offset 0x2480 0x2480: 0x0008, 0x2481: 0x0008, 0x2482: 0x0001, 0x2483: 0x0001, 0x2484: 0x0001, 0x2485: 0x0001, 0x2486: 0x0001, 0x2487: 0x0001, 0x2488: 0x0001, 0x2489: 0x0001, 0x248a: 0x0001, 0x248b: 0x0001, 0x248c: 0x0001, 0x248d: 0x0001, 0x248e: 0x0001, 0x248f: 0x0001, 0x2490: 0x0001, 0x2491: 0x0001, 0x2492: 0x0001, 0x2493: 0x0001, 0x2494: 0x0001, 0x2495: 0x0001, 0x2496: 0x0001, 0x2497: 0x0001, 0x2498: 0x0001, 0x2499: 0x0001, 0x249a: 0x0001, 0x249b: 0x0001, 0x249c: 0x0001, 0x249d: 0x0001, 0x249e: 0x0001, 0x249f: 0x0001, 0x24a0: 0x0001, 0x24a1: 0x0001, 0x24a2: 0x0001, 0x24a3: 0x0001, 0x24a4: 0x0001, 0x24a5: 0x0001, 0x24a6: 0x0001, 0x24a7: 0x0001, 0x24a8: 0x0001, 0x24a9: 0x0001, 0x24aa: 0x0001, 0x24ab: 0x0001, 0x24ac: 0x0001, 0x24ad: 0x0001, 0x24ae: 0x0001, 0x24af: 0x0001, 0x24b0: 0x0001, 0x24b1: 0x0001, 0x24b2: 0x0001, 0x24b3: 0x0001, 0x24b4: 0x0008, 0x24b5: 0x0008, 0x24b6: 0x0008, 0x24b7: 0x0008, 0x24b8: 0x0008, 0x24b9: 0x0008, 0x24ba: 0x0008, 0x24bb: 0x0008, 0x24bc: 0x0008, 0x24bd: 0x0008, 0x24be: 0x0008, 0x24bf: 0x0008, // Block 0x93, offset 0x24c0 0x24c0: 0x0008, 0x24c1: 0x0008, 0x24c2: 0x0008, 0x24c3: 0x0008, 0x24c4: 0x0008, 0x24c5: 0x0008, 0x24d0: 0x4000, 0x24d1: 0x4000, 0x24d2: 0x4000, 0x24d3: 0x4000, 0x24d4: 0x4000, 0x24d5: 0x4000, 0x24d6: 0x4000, 0x24d7: 0x4000, 0x24d8: 0x4000, 0x24d9: 0x4000, 0x24e0: 0x0008, 0x24e1: 0x0008, 0x24e2: 0x0008, 0x24e3: 0x0008, 0x24e4: 0x0008, 0x24e5: 0x0008, 0x24e6: 0x0008, 0x24e7: 0x0008, 0x24e8: 0x0008, 0x24e9: 0x0008, 0x24ea: 0x0008, 0x24eb: 0x0008, 0x24ec: 0x0008, 0x24ed: 0x0008, 0x24ee: 0x0008, 0x24ef: 0x0008, 0x24f0: 0x0008, 0x24f1: 0x0008, 0x24f2: 0x0001, 0x24f3: 0x0001, 0x24f4: 0x0001, 0x24f5: 0x0001, 0x24f6: 0x0001, 0x24f7: 0x0001, 0x24fb: 0x0001, 0x24fd: 0x0001, 0x24fe: 0x0001, 0x24ff: 0x0008, // Block 0x94, offset 0x2500 0x2500: 0x4000, 0x2501: 0x4000, 0x2502: 0x4000, 0x2503: 0x4000, 0x2504: 0x4000, 0x2505: 0x4000, 0x2506: 0x4000, 0x2507: 0x4000, 0x2508: 0x4000, 0x2509: 0x4000, 0x250a: 0x0001, 0x250b: 0x0001, 0x250c: 0x0001, 0x250d: 0x0001, 0x250e: 0x0001, 0x250f: 0x0001, 0x2510: 0x0001, 0x2511: 0x0001, 0x2512: 0x0001, 0x2513: 0x0001, 0x2514: 0x0001, 0x2515: 0x0001, 0x2516: 0x0001, 0x2517: 0x0001, 0x2518: 0x0001, 0x2519: 0x0001, 0x251a: 0x0001, 0x251b: 0x0001, 0x251c: 0x0001, 0x251d: 0x0001, 0x251e: 0x0001, 0x251f: 0x0001, 0x2520: 0x0001, 0x2521: 0x0001, 0x2522: 0x0001, 0x2523: 0x0001, 0x2524: 0x0001, 0x2525: 0x0001, 0x2526: 0x0008, 0x2527: 0x0008, 0x2528: 0x0008, 0x2529: 0x0008, 0x252a: 0x0008, 0x252b: 0x0008, 0x252c: 0x0008, 0x252d: 0x0008, 0x2530: 0x0001, 0x2531: 0x0001, 0x2532: 0x0001, 0x2533: 0x0001, 0x2534: 0x0001, 0x2535: 0x0001, 0x2536: 0x0001, 0x2537: 0x0001, 0x2538: 0x0001, 0x2539: 0x0001, 0x253a: 0x0001, 0x253b: 0x0001, 0x253c: 0x0001, 0x253d: 0x0001, 0x253e: 0x0001, 0x253f: 0x0001, // Block 0x95, offset 0x2540 0x2540: 0x0001, 0x2541: 0x0001, 0x2542: 0x0001, 0x2543: 0x0001, 0x2544: 0x0001, 0x2545: 0x0001, 0x2546: 0x0001, 0x2547: 0x0008, 0x2548: 0x0008, 0x2549: 0x0008, 0x254a: 0x0008, 0x254b: 0x0008, 0x254c: 0x0008, 0x254d: 0x0008, 0x254e: 0x0008, 0x254f: 0x0008, 0x2550: 0x0008, 0x2551: 0x0008, 0x2552: 0x0008, 0x2553: 0x0008, 0x2560: 0x0001, 0x2561: 0x0001, 0x2562: 0x0001, 0x2563: 0x0001, 0x2564: 0x0001, 0x2565: 0x0001, 0x2566: 0x0001, 0x2567: 0x0001, 0x2568: 0x0001, 0x2569: 0x0001, 0x256a: 0x0001, 0x256b: 0x0001, 0x256c: 0x0001, 0x256d: 0x0001, 0x256e: 0x0001, 0x256f: 0x0001, 0x2570: 0x0001, 0x2571: 0x0001, 0x2572: 0x0001, 0x2573: 0x0001, 0x2574: 0x0001, 0x2575: 0x0001, 0x2576: 0x0001, 0x2577: 0x0001, 0x2578: 0x0001, 0x2579: 0x0001, 0x257a: 0x0001, 0x257b: 0x0001, 0x257c: 0x0001, // Block 0x96, offset 0x2580 0x2580: 0x0008, 0x2581: 0x0008, 0x2582: 0x0008, 0x2583: 0x0008, 0x2584: 0x0001, 0x2585: 0x0001, 0x2586: 0x0001, 0x2587: 0x0001, 0x2588: 0x0001, 0x2589: 0x0001, 0x258a: 0x0001, 0x258b: 0x0001, 0x258c: 0x0001, 0x258d: 0x0001, 0x258e: 0x0001, 0x258f: 0x0001, 0x2590: 0x0001, 0x2591: 0x0001, 0x2592: 0x0001, 0x2593: 0x0001, 0x2594: 0x0001, 0x2595: 0x0001, 0x2596: 0x0001, 0x2597: 0x0001, 0x2598: 0x0001, 0x2599: 0x0001, 0x259a: 0x0001, 0x259b: 0x0001, 0x259c: 0x0001, 0x259d: 0x0001, 0x259e: 0x0001, 0x259f: 0x0001, 0x25a0: 0x0001, 0x25a1: 0x0001, 0x25a2: 0x0001, 0x25a3: 0x0001, 0x25a4: 0x0001, 0x25a5: 0x0001, 0x25a6: 0x0001, 0x25a7: 0x0001, 0x25a8: 0x0001, 0x25a9: 0x0001, 0x25aa: 0x0001, 0x25ab: 0x0001, 0x25ac: 0x0001, 0x25ad: 0x0001, 0x25ae: 0x0001, 0x25af: 0x0001, 0x25b0: 0x0001, 0x25b1: 0x0001, 0x25b2: 0x0001, 0x25b3: 0x0008, 0x25b4: 0x0008, 0x25b5: 0x0008, 0x25b6: 0x0008, 0x25b7: 0x0008, 0x25b8: 0x0008, 0x25b9: 0x0008, 0x25ba: 0x0008, 0x25bb: 0x0008, 0x25bc: 0x0008, 0x25bd: 0x0008, 0x25be: 0x0008, 0x25bf: 0x0008, // Block 0x97, offset 0x25c0 0x25c0: 0x0008, 0x25cf: 0x0001, 0x25d0: 0x4000, 0x25d1: 0x4000, 0x25d2: 0x4000, 0x25d3: 0x4000, 0x25d4: 0x4000, 0x25d5: 0x4000, 0x25d6: 0x4000, 0x25d7: 0x4000, 0x25d8: 0x4000, 0x25d9: 0x4000, 0x25e5: 0x0008, 0x25f0: 0x4000, 0x25f1: 0x4000, 0x25f2: 0x4000, 0x25f3: 0x4000, 0x25f4: 0x4000, 0x25f5: 0x4000, 0x25f6: 0x4000, 0x25f7: 0x4000, 0x25f8: 0x4000, 0x25f9: 0x4000, // Block 0x98, offset 0x2600 0x2600: 0x0001, 0x2601: 0x0001, 0x2602: 0x0001, 0x2603: 0x0001, 0x2604: 0x0001, 0x2605: 0x0001, 0x2606: 0x0001, 0x2607: 0x0001, 0x2608: 0x0001, 0x2609: 0x0001, 0x260a: 0x0001, 0x260b: 0x0001, 0x260c: 0x0001, 0x260d: 0x0001, 0x260e: 0x0001, 0x260f: 0x0001, 0x2610: 0x0001, 0x2611: 0x0001, 0x2612: 0x0001, 0x2613: 0x0001, 0x2614: 0x0001, 0x2615: 0x0001, 0x2616: 0x0001, 0x2617: 0x0001, 0x2618: 0x0001, 0x2619: 0x0001, 0x261a: 0x0001, 0x261b: 0x0001, 0x261c: 0x0001, 0x261d: 0x0001, 0x261e: 0x0001, 0x261f: 0x0001, 0x2620: 0x0001, 0x2621: 0x0001, 0x2622: 0x0001, 0x2623: 0x0001, 0x2624: 0x0001, 0x2625: 0x0001, 0x2626: 0x0001, 0x2627: 0x0001, 0x2628: 0x0001, 0x2629: 0x0008, 0x262a: 0x0008, 0x262b: 0x0008, 0x262c: 0x0008, 0x262d: 0x0008, 0x262e: 0x0008, 0x262f: 0x0008, 0x2630: 0x0008, 0x2631: 0x0008, 0x2632: 0x0008, 0x2633: 0x0008, 0x2634: 0x0008, 0x2635: 0x0008, 0x2636: 0x0008, // Block 0x99, offset 0x2640 0x2640: 0x0001, 0x2641: 0x0001, 0x2642: 0x0001, 0x2643: 0x0008, 0x2644: 0x0001, 0x2645: 0x0001, 0x2646: 0x0001, 0x2647: 0x0001, 0x2648: 0x0001, 0x2649: 0x0001, 0x264a: 0x0001, 0x264b: 0x0001, 0x264c: 0x0008, 0x264d: 0x0008, 0x2650: 0x4000, 0x2651: 0x4000, 0x2652: 0x4000, 0x2653: 0x4000, 0x2654: 0x4000, 0x2655: 0x4000, 0x2656: 0x4000, 0x2657: 0x4000, 0x2658: 0x4000, 0x2659: 0x4000, 0x267b: 0x0008, 0x267c: 0x0008, 0x267d: 0x0008, // Block 0x9a, offset 0x2680 0x26b0: 0x0008, 0x26b2: 0x0008, 0x26b3: 0x0008, 0x26b4: 0x0008, 0x26b7: 0x0008, 0x26b8: 0x0008, 0x26be: 0x0008, 0x26bf: 0x0008, // Block 0x9b, offset 0x26c0 0x26c1: 0x0008, 0x26e0: 0x0001, 0x26e1: 0x0001, 0x26e2: 0x0001, 0x26e3: 0x0001, 0x26e4: 0x0001, 0x26e5: 0x0001, 0x26e6: 0x0001, 0x26e7: 0x0001, 0x26e8: 0x0001, 0x26e9: 0x0001, 0x26ea: 0x0001, 0x26eb: 0x0008, 0x26ec: 0x0008, 0x26ed: 0x0008, 0x26ee: 0x0008, 0x26ef: 0x0008, 0x26f2: 0x0001, 0x26f3: 0x0001, 0x26f4: 0x0001, 0x26f5: 0x0008, 0x26f6: 0x0008, // Block 0x9c, offset 0x2700 0x2701: 0x0001, 0x2702: 0x0001, 0x2703: 0x0001, 0x2704: 0x0001, 0x2705: 0x0001, 0x2706: 0x0001, 0x2709: 0x0001, 0x270a: 0x0001, 0x270b: 0x0001, 0x270c: 0x0001, 0x270d: 0x0001, 0x270e: 0x0001, 0x2711: 0x0001, 0x2712: 0x0001, 0x2713: 0x0001, 0x2714: 0x0001, 0x2715: 0x0001, 0x2716: 0x0001, 0x2720: 0x0001, 0x2721: 0x0001, 0x2722: 0x0001, 0x2723: 0x0001, 0x2724: 0x0001, 0x2725: 0x0001, 0x2726: 0x0001, 0x2728: 0x0001, 0x2729: 0x0001, 0x272a: 0x0001, 0x272b: 0x0001, 0x272c: 0x0001, 0x272d: 0x0001, 0x272e: 0x0001, 0x2730: 0x0001, 0x2731: 0x0001, 0x2732: 0x0001, 0x2733: 0x0001, 0x2734: 0x0001, 0x2735: 0x0001, 0x2736: 0x0001, 0x2737: 0x0001, 0x2738: 0x0001, 0x2739: 0x0001, 0x273a: 0x0001, 0x273b: 0x0001, 0x273c: 0x0001, 0x273d: 0x0001, 0x273e: 0x0001, 0x273f: 0x0001, // Block 0x9d, offset 0x2740 0x2740: 0x0001, 0x2741: 0x0001, 0x2742: 0x0001, 0x2743: 0x0001, 0x2744: 0x0001, 0x2745: 0x0001, 0x2746: 0x0001, 0x2747: 0x0001, 0x2748: 0x0001, 0x2749: 0x0001, 0x274a: 0x0001, 0x274b: 0x0001, 0x274c: 0x0001, 0x274d: 0x0001, 0x274e: 0x0001, 0x274f: 0x0001, 0x2750: 0x0001, 0x2751: 0x0001, 0x2752: 0x0001, 0x2753: 0x0001, 0x2754: 0x0001, 0x2755: 0x0001, 0x2756: 0x0001, 0x2757: 0x0001, 0x2758: 0x0001, 0x2759: 0x0001, 0x275a: 0x0001, 0x275b: 0x0001, 0x275c: 0x0001, 0x275d: 0x0001, 0x275e: 0x0001, 0x275f: 0x0001, 0x2760: 0x0001, 0x2761: 0x0001, 0x2762: 0x0001, 0x2763: 0x0001, 0x2764: 0x0001, 0x2765: 0x0001, 0x2766: 0x0001, 0x2767: 0x0001, 0x2768: 0x0001, 0x2769: 0x0001, 0x2770: 0x0001, 0x2771: 0x0001, 0x2772: 0x0001, 0x2773: 0x0001, 0x2774: 0x0001, 0x2775: 0x0001, 0x2776: 0x0001, 0x2777: 0x0001, 0x2778: 0x0001, 0x2779: 0x0001, 0x277a: 0x0001, 0x277b: 0x0001, 0x277c: 0x0001, 0x277d: 0x0001, 0x277e: 0x0001, 0x277f: 0x0001, // Block 0x9e, offset 0x2780 0x2780: 0x0001, 0x2781: 0x0001, 0x2782: 0x0001, 0x2783: 0x0001, 0x2784: 0x0001, 0x2785: 0x0001, 0x2786: 0x0001, 0x2787: 0x0001, 0x2788: 0x0001, 0x2789: 0x0001, 0x278a: 0x0001, 0x278b: 0x0001, 0x278c: 0x0001, 0x278d: 0x0001, 0x278e: 0x0001, 0x278f: 0x0001, 0x2790: 0x0001, 0x2791: 0x0001, 0x2792: 0x0001, 0x2793: 0x0001, 0x2794: 0x0001, 0x2795: 0x0001, 0x2796: 0x0001, 0x2797: 0x0001, 0x2798: 0x0001, 0x2799: 0x0001, 0x279a: 0x0001, 0x279b: 0x0001, 0x279c: 0x0001, 0x279d: 0x0001, 0x279e: 0x0001, 0x279f: 0x0001, 0x27a0: 0x0001, 0x27a1: 0x0001, 0x27a2: 0x0001, 0x27a3: 0x0008, 0x27a4: 0x0008, 0x27a5: 0x0008, 0x27a6: 0x0008, 0x27a7: 0x0008, 0x27a8: 0x0008, 0x27a9: 0x0008, 0x27aa: 0x0008, 0x27ac: 0x0008, 0x27ad: 0x0008, 0x27b0: 0x4000, 0x27b1: 0x4000, 0x27b2: 0x4000, 0x27b3: 0x4000, 0x27b4: 0x4000, 0x27b5: 0x4000, 0x27b6: 0x4000, 0x27b7: 0x4000, 0x27b8: 0x4000, 0x27b9: 0x4000, // Block 0x9f, offset 0x27c0 0x27c0: 0x0001, 0x27c1: 0x0001, 0x27c2: 0x0001, 0x27c3: 0x0001, 0x27c4: 0x0001, 0x27c5: 0x0001, 0x27c6: 0x0001, 0x27c7: 0x0001, 0x27c8: 0x0001, 0x27c9: 0x0001, 0x27ca: 0x0001, 0x27cb: 0x0001, 0x27cc: 0x0001, 0x27cd: 0x0001, 0x27ce: 0x0001, 0x27cf: 0x0001, 0x27d0: 0x0001, 0x27d1: 0x0001, 0x27d2: 0x0001, 0x27d3: 0x0001, 0x27d4: 0x0001, 0x27d5: 0x0001, 0x27d6: 0x0001, 0x27d7: 0x0001, 0x27d8: 0x0001, 0x27d9: 0x0001, 0x27da: 0x0001, 0x27db: 0x0001, 0x27dc: 0x0001, 0x27dd: 0x0001, 0x27de: 0x0001, 0x27df: 0x0001, 0x27e0: 0x0001, 0x27e1: 0x0001, 0x27e2: 0x0001, 0x27e3: 0x0001, 0x27f0: 0x0001, 0x27f1: 0x0001, 0x27f2: 0x0001, 0x27f3: 0x0001, 0x27f4: 0x0001, 0x27f5: 0x0001, 0x27f6: 0x0001, 0x27f7: 0x0001, 0x27f8: 0x0001, 0x27f9: 0x0001, 0x27fa: 0x0001, 0x27fb: 0x0001, 0x27fc: 0x0001, 0x27fd: 0x0001, 0x27fe: 0x0001, 0x27ff: 0x0001, // Block 0xa0, offset 0x2800 0x2800: 0x0001, 0x2801: 0x0001, 0x2802: 0x0001, 0x2803: 0x0001, 0x2804: 0x0001, 0x2805: 0x0001, 0x2806: 0x0001, 0x280b: 0x0001, 0x280c: 0x0001, 0x280d: 0x0001, 0x280e: 0x0001, 0x280f: 0x0001, 0x2810: 0x0001, 0x2811: 0x0001, 0x2812: 0x0001, 0x2813: 0x0001, 0x2814: 0x0001, 0x2815: 0x0001, 0x2816: 0x0001, 0x2817: 0x0001, 0x2818: 0x0001, 0x2819: 0x0001, 0x281a: 0x0001, 0x281b: 0x0001, 0x281c: 0x0001, 0x281d: 0x0001, 0x281e: 0x0001, 0x281f: 0x0001, 0x2820: 0x0001, 0x2821: 0x0001, 0x2822: 0x0001, 0x2823: 0x0001, 0x2824: 0x0001, 0x2825: 0x0001, 0x2826: 0x0001, 0x2827: 0x0001, 0x2828: 0x0001, 0x2829: 0x0001, 0x282a: 0x0001, 0x282b: 0x0001, 0x282c: 0x0001, 0x282d: 0x0001, 0x282e: 0x0001, 0x282f: 0x0001, 0x2830: 0x0001, 0x2831: 0x0001, 0x2832: 0x0001, 0x2833: 0x0001, 0x2834: 0x0001, 0x2835: 0x0001, 0x2836: 0x0001, 0x2837: 0x0001, 0x2838: 0x0001, 0x2839: 0x0001, 0x283a: 0x0001, 0x283b: 0x0001, // Block 0xa1, offset 0x2840 0x2840: 0x0001, 0x2841: 0x0001, 0x2842: 0x0001, 0x2843: 0x0001, 0x2844: 0x0001, 0x2845: 0x0001, 0x2846: 0x0001, 0x2853: 0x0001, 0x2854: 0x0001, 0x2855: 0x0001, 0x2856: 0x0001, 0x2857: 0x0001, 0x285d: 0x0080, 0x285e: 0x0008, 0x285f: 0x0080, 0x2860: 0x0080, 0x2861: 0x0080, 0x2862: 0x0080, 0x2863: 0x0080, 0x2864: 0x0080, 0x2865: 0x0080, 0x2866: 0x0080, 0x2867: 0x0080, 0x2868: 0x0080, 0x286a: 0x0080, 0x286b: 0x0080, 0x286c: 0x0080, 0x286d: 0x0080, 0x286e: 0x0080, 0x286f: 0x0080, 0x2870: 0x0080, 0x2871: 0x0080, 0x2872: 0x0080, 0x2873: 0x0080, 0x2874: 0x0080, 0x2875: 0x0080, 0x2876: 0x0080, 0x2878: 0x0080, 0x2879: 0x0080, 0x287a: 0x0080, 0x287b: 0x0080, 0x287c: 0x0080, 0x287e: 0x0080, // Block 0xa2, offset 0x2880 0x2880: 0x0080, 0x2881: 0x0080, 0x2883: 0x0080, 0x2884: 0x0080, 0x2886: 0x0080, 0x2887: 0x0080, 0x2888: 0x0080, 0x2889: 0x0080, 0x288a: 0x0080, 0x288b: 0x0080, 0x288c: 0x0080, 0x288d: 0x0080, 0x288e: 0x0080, 0x288f: 0x0080, 0x2890: 0x0001, 0x2891: 0x0001, 0x2892: 0x0001, 0x2893: 0x0001, 0x2894: 0x0001, 0x2895: 0x0001, 0x2896: 0x0001, 0x2897: 0x0001, 0x2898: 0x0001, 0x2899: 0x0001, 0x289a: 0x0001, 0x289b: 0x0001, 0x289c: 0x0001, 0x289d: 0x0001, 0x289e: 0x0001, 0x289f: 0x0001, 0x28a0: 0x0001, 0x28a1: 0x0001, 0x28a2: 0x0001, 0x28a3: 0x0001, 0x28a4: 0x0001, 0x28a5: 0x0001, 0x28a6: 0x0001, 0x28a7: 0x0001, 0x28a8: 0x0001, 0x28a9: 0x0001, 0x28aa: 0x0001, 0x28ab: 0x0001, 0x28ac: 0x0001, 0x28ad: 0x0001, 0x28ae: 0x0001, 0x28af: 0x0001, 0x28b0: 0x0001, 0x28b1: 0x0001, 0x28b2: 0x0001, 0x28b3: 0x0001, 0x28b4: 0x0001, 0x28b5: 0x0001, 0x28b6: 0x0001, 0x28b7: 0x0001, 0x28b8: 0x0001, 0x28b9: 0x0001, 0x28ba: 0x0001, 0x28bb: 0x0001, 0x28bc: 0x0001, 0x28bd: 0x0001, 0x28be: 0x0001, 0x28bf: 0x0001, // Block 0xa3, offset 0x28c0 0x28c0: 0x0001, 0x28c1: 0x0001, 0x28c2: 0x0001, 0x28c3: 0x0001, 0x28c4: 0x0001, 0x28c5: 0x0001, 0x28c6: 0x0001, 0x28c7: 0x0001, 0x28c8: 0x0001, 0x28c9: 0x0001, 0x28ca: 0x0001, 0x28cb: 0x0001, 0x28cc: 0x0001, 0x28cd: 0x0001, 0x28ce: 0x0001, 0x28cf: 0x0001, 0x28d0: 0x0001, 0x28d1: 0x0001, 0x28d2: 0x0001, 0x28d3: 0x0001, 0x28d4: 0x0001, 0x28d5: 0x0001, 0x28d6: 0x0001, 0x28d7: 0x0001, 0x28d8: 0x0001, 0x28d9: 0x0001, 0x28da: 0x0001, 0x28db: 0x0001, 0x28dc: 0x0001, 0x28dd: 0x0001, 0x28de: 0x0001, 0x28df: 0x0001, 0x28e0: 0x0001, 0x28e1: 0x0001, 0x28e2: 0x0001, 0x28e3: 0x0001, 0x28e4: 0x0001, 0x28e5: 0x0001, 0x28e6: 0x0001, 0x28e7: 0x0001, 0x28e8: 0x0001, 0x28e9: 0x0001, 0x28ea: 0x0001, 0x28eb: 0x0001, 0x28ec: 0x0001, 0x28ed: 0x0001, 0x28ee: 0x0001, 0x28ef: 0x0001, 0x28f0: 0x0001, 0x28f1: 0x0001, // Block 0xa4, offset 0x2900 0x2913: 0x0001, 0x2914: 0x0001, 0x2915: 0x0001, 0x2916: 0x0001, 0x2917: 0x0001, 0x2918: 0x0001, 0x2919: 0x0001, 0x291a: 0x0001, 0x291b: 0x0001, 0x291c: 0x0001, 0x291d: 0x0001, 0x291e: 0x0001, 0x291f: 0x0001, 0x2920: 0x0001, 0x2921: 0x0001, 0x2922: 0x0001, 0x2923: 0x0001, 0x2924: 0x0001, 0x2925: 0x0001, 0x2926: 0x0001, 0x2927: 0x0001, 0x2928: 0x0001, 0x2929: 0x0001, 0x292a: 0x0001, 0x292b: 0x0001, 0x292c: 0x0001, 0x292d: 0x0001, 0x292e: 0x0001, 0x292f: 0x0001, 0x2930: 0x0001, 0x2931: 0x0001, 0x2932: 0x0001, 0x2933: 0x0001, 0x2934: 0x0001, 0x2935: 0x0001, 0x2936: 0x0001, 0x2937: 0x0001, 0x2938: 0x0001, 0x2939: 0x0001, 0x293a: 0x0001, 0x293b: 0x0001, 0x293c: 0x0001, 0x293d: 0x0001, 0x293e: 0x0001, 0x293f: 0x0001, // Block 0xa5, offset 0x2940 0x2940: 0x0001, 0x2941: 0x0001, 0x2942: 0x0001, 0x2943: 0x0001, 0x2944: 0x0001, 0x2945: 0x0001, 0x2946: 0x0001, 0x2947: 0x0001, 0x2948: 0x0001, 0x2949: 0x0001, 0x294a: 0x0001, 0x294b: 0x0001, 0x294c: 0x0001, 0x294d: 0x0001, 0x294e: 0x0001, 0x294f: 0x0001, 0x2950: 0x0001, 0x2951: 0x0001, 0x2952: 0x0001, 0x2953: 0x0001, 0x2954: 0x0001, 0x2955: 0x0001, 0x2956: 0x0001, 0x2957: 0x0001, 0x2958: 0x0001, 0x2959: 0x0001, 0x295a: 0x0001, 0x295b: 0x0001, 0x295c: 0x0001, 0x295d: 0x0001, 0x295e: 0x0001, 0x295f: 0x0001, 0x2960: 0x0001, 0x2961: 0x0001, 0x2962: 0x0001, 0x2963: 0x0001, 0x2964: 0x0001, 0x2965: 0x0001, 0x2966: 0x0001, 0x2967: 0x0001, 0x2968: 0x0001, 0x2969: 0x0001, 0x296a: 0x0001, 0x296b: 0x0001, 0x296c: 0x0001, 0x296d: 0x0001, 0x296e: 0x0001, 0x296f: 0x0001, 0x2970: 0x0001, 0x2971: 0x0001, 0x2972: 0x0001, 0x2973: 0x0001, 0x2974: 0x0001, 0x2975: 0x0001, 0x2976: 0x0001, 0x2977: 0x0001, 0x2978: 0x0001, 0x2979: 0x0001, 0x297a: 0x0001, 0x297b: 0x0001, 0x297c: 0x0001, 0x297d: 0x0001, // Block 0xa6, offset 0x2980 0x2990: 0x0001, 0x2991: 0x0001, 0x2992: 0x0001, 0x2993: 0x0001, 0x2994: 0x0001, 0x2995: 0x0001, 0x2996: 0x0001, 0x2997: 0x0001, 0x2998: 0x0001, 0x2999: 0x0001, 0x299a: 0x0001, 0x299b: 0x0001, 0x299c: 0x0001, 0x299d: 0x0001, 0x299e: 0x0001, 0x299f: 0x0001, 0x29a0: 0x0001, 0x29a1: 0x0001, 0x29a2: 0x0001, 0x29a3: 0x0001, 0x29a4: 0x0001, 0x29a5: 0x0001, 0x29a6: 0x0001, 0x29a7: 0x0001, 0x29a8: 0x0001, 0x29a9: 0x0001, 0x29aa: 0x0001, 0x29ab: 0x0001, 0x29ac: 0x0001, 0x29ad: 0x0001, 0x29ae: 0x0001, 0x29af: 0x0001, 0x29b0: 0x0001, 0x29b1: 0x0001, 0x29b2: 0x0001, 0x29b3: 0x0001, 0x29b4: 0x0001, 0x29b5: 0x0001, 0x29b6: 0x0001, 0x29b7: 0x0001, 0x29b8: 0x0001, 0x29b9: 0x0001, 0x29ba: 0x0001, 0x29bb: 0x0001, 0x29bc: 0x0001, 0x29bd: 0x0001, 0x29be: 0x0001, 0x29bf: 0x0001, // Block 0xa7, offset 0x29c0 0x29c0: 0x0001, 0x29c1: 0x0001, 0x29c2: 0x0001, 0x29c3: 0x0001, 0x29c4: 0x0001, 0x29c5: 0x0001, 0x29c6: 0x0001, 0x29c7: 0x0001, 0x29c8: 0x0001, 0x29c9: 0x0001, 0x29ca: 0x0001, 0x29cb: 0x0001, 0x29cc: 0x0001, 0x29cd: 0x0001, 0x29ce: 0x0001, 0x29cf: 0x0001, 0x29d2: 0x0001, 0x29d3: 0x0001, 0x29d4: 0x0001, 0x29d5: 0x0001, 0x29d6: 0x0001, 0x29d7: 0x0001, 0x29d8: 0x0001, 0x29d9: 0x0001, 0x29da: 0x0001, 0x29db: 0x0001, 0x29dc: 0x0001, 0x29dd: 0x0001, 0x29de: 0x0001, 0x29df: 0x0001, 0x29e0: 0x0001, 0x29e1: 0x0001, 0x29e2: 0x0001, 0x29e3: 0x0001, 0x29e4: 0x0001, 0x29e5: 0x0001, 0x29e6: 0x0001, 0x29e7: 0x0001, 0x29e8: 0x0001, 0x29e9: 0x0001, 0x29ea: 0x0001, 0x29eb: 0x0001, 0x29ec: 0x0001, 0x29ed: 0x0001, 0x29ee: 0x0001, 0x29ef: 0x0001, 0x29f0: 0x0001, 0x29f1: 0x0001, 0x29f2: 0x0001, 0x29f3: 0x0001, 0x29f4: 0x0001, 0x29f5: 0x0001, 0x29f6: 0x0001, 0x29f7: 0x0001, 0x29f8: 0x0001, 0x29f9: 0x0001, 0x29fa: 0x0001, 0x29fb: 0x0001, 0x29fc: 0x0001, 0x29fd: 0x0001, 0x29fe: 0x0001, 0x29ff: 0x0001, // Block 0xa8, offset 0x2a00 0x2a00: 0x0001, 0x2a01: 0x0001, 0x2a02: 0x0001, 0x2a03: 0x0001, 0x2a04: 0x0001, 0x2a05: 0x0001, 0x2a06: 0x0001, 0x2a07: 0x0001, 0x2a30: 0x0001, 0x2a31: 0x0001, 0x2a32: 0x0001, 0x2a33: 0x0001, 0x2a34: 0x0001, 0x2a35: 0x0001, 0x2a36: 0x0001, 0x2a37: 0x0001, 0x2a38: 0x0001, 0x2a39: 0x0001, 0x2a3a: 0x0001, 0x2a3b: 0x0001, // Block 0xa9, offset 0x2a40 0x2a40: 0x0008, 0x2a41: 0x0008, 0x2a42: 0x0008, 0x2a43: 0x0008, 0x2a44: 0x0008, 0x2a45: 0x0008, 0x2a46: 0x0008, 0x2a47: 0x0008, 0x2a48: 0x0008, 0x2a49: 0x0008, 0x2a4a: 0x0008, 0x2a4b: 0x0008, 0x2a4c: 0x0008, 0x2a4d: 0x0008, 0x2a4e: 0x0008, 0x2a4f: 0x0008, 0x2a53: 0x0400, 0x2a60: 0x0008, 0x2a61: 0x0008, 0x2a62: 0x0008, 0x2a63: 0x0008, 0x2a64: 0x0008, 0x2a65: 0x0008, 0x2a66: 0x0008, 0x2a67: 0x0008, 0x2a68: 0x0008, 0x2a69: 0x0008, 0x2a6a: 0x0008, 0x2a6b: 0x0008, 0x2a6c: 0x0008, 0x2a6d: 0x0008, 0x2a6e: 0x0008, 0x2a6f: 0x0008, 0x2a73: 0x0010, 0x2a74: 0x0010, // Block 0xaa, offset 0x2a80 0x2a8d: 0x0010, 0x2a8e: 0x0010, 0x2a8f: 0x0010, 0x2a90: 0x0800, 0x2a92: 0x1000, 0x2a94: 0x0800, 0x2a95: 0x0400, 0x2ab0: 0x0001, 0x2ab1: 0x0001, 0x2ab2: 0x0001, 0x2ab3: 0x0001, 0x2ab4: 0x0001, 0x2ab6: 0x0001, 0x2ab7: 0x0001, 0x2ab8: 0x0001, 0x2ab9: 0x0001, 0x2aba: 0x0001, 0x2abb: 0x0001, 0x2abc: 0x0001, 0x2abd: 0x0001, 0x2abe: 0x0001, 0x2abf: 0x0001, // Block 0xab, offset 0x2ac0 0x2ac0: 0x0001, 0x2ac1: 0x0001, 0x2ac2: 0x0001, 0x2ac3: 0x0001, 0x2ac4: 0x0001, 0x2ac5: 0x0001, 0x2ac6: 0x0001, 0x2ac7: 0x0001, 0x2ac8: 0x0001, 0x2ac9: 0x0001, 0x2aca: 0x0001, 0x2acb: 0x0001, 0x2acc: 0x0001, 0x2acd: 0x0001, 0x2ace: 0x0001, 0x2acf: 0x0001, 0x2ad0: 0x0001, 0x2ad1: 0x0001, 0x2ad2: 0x0001, 0x2ad3: 0x0001, 0x2ad4: 0x0001, 0x2ad5: 0x0001, 0x2ad6: 0x0001, 0x2ad7: 0x0001, 0x2ad8: 0x0001, 0x2ad9: 0x0001, 0x2ada: 0x0001, 0x2adb: 0x0001, 0x2adc: 0x0001, 0x2add: 0x0001, 0x2ade: 0x0001, 0x2adf: 0x0001, 0x2ae0: 0x0001, 0x2ae1: 0x0001, 0x2ae2: 0x0001, 0x2ae3: 0x0001, 0x2ae4: 0x0001, 0x2ae5: 0x0001, 0x2ae6: 0x0001, 0x2ae7: 0x0001, 0x2ae8: 0x0001, 0x2ae9: 0x0001, 0x2aea: 0x0001, 0x2aeb: 0x0001, 0x2aec: 0x0001, 0x2aed: 0x0001, 0x2aee: 0x0001, 0x2aef: 0x0001, 0x2af0: 0x0001, 0x2af1: 0x0001, 0x2af2: 0x0001, 0x2af3: 0x0001, 0x2af4: 0x0001, 0x2af5: 0x0001, 0x2af6: 0x0001, 0x2af7: 0x0001, 0x2af8: 0x0001, 0x2af9: 0x0001, 0x2afa: 0x0001, 0x2afb: 0x0001, 0x2afc: 0x0001, 0x2aff: 0x0040, // Block 0xac, offset 0x2b00 0x2b07: 0x1000, 0x2b0c: 0x0800, 0x2b0e: 0x1000, 0x2b10: 0x4000, 0x2b11: 0x4000, 0x2b12: 0x4000, 0x2b13: 0x4000, 0x2b14: 0x4000, 0x2b15: 0x4000, 0x2b16: 0x4000, 0x2b17: 0x4000, 0x2b18: 0x4000, 0x2b19: 0x4000, 0x2b1a: 0x0400, 0x2b1b: 0x0800, 0x2b21: 0x0001, 0x2b22: 0x0001, 0x2b23: 0x0001, 0x2b24: 0x0001, 0x2b25: 0x0001, 0x2b26: 0x0001, 0x2b27: 0x0001, 0x2b28: 0x0001, 0x2b29: 0x0001, 0x2b2a: 0x0001, 0x2b2b: 0x0001, 0x2b2c: 0x0001, 0x2b2d: 0x0001, 0x2b2e: 0x0001, 0x2b2f: 0x0001, 0x2b30: 0x0001, 0x2b31: 0x0001, 0x2b32: 0x0001, 0x2b33: 0x0001, 0x2b34: 0x0001, 0x2b35: 0x0001, 0x2b36: 0x0001, 0x2b37: 0x0001, 0x2b38: 0x0001, 0x2b39: 0x0001, 0x2b3a: 0x0001, 0x2b3f: 0x0010, // Block 0xad, offset 0x2b40 0x2b41: 0x0001, 0x2b42: 0x0001, 0x2b43: 0x0001, 0x2b44: 0x0001, 0x2b45: 0x0001, 0x2b46: 0x0001, 0x2b47: 0x0001, 0x2b48: 0x0001, 0x2b49: 0x0001, 0x2b4a: 0x0001, 0x2b4b: 0x0001, 0x2b4c: 0x0001, 0x2b4d: 0x0001, 0x2b4e: 0x0001, 0x2b4f: 0x0001, 0x2b50: 0x0001, 0x2b51: 0x0001, 0x2b52: 0x0001, 0x2b53: 0x0001, 0x2b54: 0x0001, 0x2b55: 0x0001, 0x2b56: 0x0001, 0x2b57: 0x0001, 0x2b58: 0x0001, 0x2b59: 0x0001, 0x2b5a: 0x0001, 0x2b66: 0x0100, 0x2b67: 0x0100, 0x2b68: 0x0100, 0x2b69: 0x0100, 0x2b6a: 0x0100, 0x2b6b: 0x0100, 0x2b6c: 0x0100, 0x2b6d: 0x0100, 0x2b6e: 0x0100, 0x2b6f: 0x0100, 0x2b70: 0x0100, 0x2b71: 0x0100, 0x2b72: 0x0100, 0x2b73: 0x0100, 0x2b74: 0x0100, 0x2b75: 0x0100, 0x2b76: 0x0100, 0x2b77: 0x0100, 0x2b78: 0x0100, 0x2b79: 0x0100, 0x2b7a: 0x0100, 0x2b7b: 0x0100, 0x2b7c: 0x0100, 0x2b7d: 0x0100, 0x2b7e: 0x0100, 0x2b7f: 0x0100, // Block 0xae, offset 0x2b80 0x2b80: 0x0100, 0x2b81: 0x0100, 0x2b82: 0x0100, 0x2b83: 0x0100, 0x2b84: 0x0100, 0x2b85: 0x0100, 0x2b86: 0x0100, 0x2b87: 0x0100, 0x2b88: 0x0100, 0x2b89: 0x0100, 0x2b8a: 0x0100, 0x2b8b: 0x0100, 0x2b8c: 0x0100, 0x2b8d: 0x0100, 0x2b8e: 0x0100, 0x2b8f: 0x0100, 0x2b90: 0x0100, 0x2b91: 0x0100, 0x2b92: 0x0100, 0x2b93: 0x0100, 0x2b94: 0x0100, 0x2b95: 0x0100, 0x2b96: 0x0100, 0x2b97: 0x0100, 0x2b98: 0x0100, 0x2b99: 0x0100, 0x2b9a: 0x0100, 0x2b9b: 0x0100, 0x2b9c: 0x0100, 0x2b9d: 0x0100, 0x2b9e: 0x0008, 0x2b9f: 0x0008, 0x2ba0: 0x0001, 0x2ba1: 0x0001, 0x2ba2: 0x0001, 0x2ba3: 0x0001, 0x2ba4: 0x0001, 0x2ba5: 0x0001, 0x2ba6: 0x0001, 0x2ba7: 0x0001, 0x2ba8: 0x0001, 0x2ba9: 0x0001, 0x2baa: 0x0001, 0x2bab: 0x0001, 0x2bac: 0x0001, 0x2bad: 0x0001, 0x2bae: 0x0001, 0x2baf: 0x0001, 0x2bb0: 0x0001, 0x2bb1: 0x0001, 0x2bb2: 0x0001, 0x2bb3: 0x0001, 0x2bb4: 0x0001, 0x2bb5: 0x0001, 0x2bb6: 0x0001, 0x2bb7: 0x0001, 0x2bb8: 0x0001, 0x2bb9: 0x0001, 0x2bba: 0x0001, 0x2bbb: 0x0001, 0x2bbc: 0x0001, 0x2bbd: 0x0001, 0x2bbe: 0x0001, // Block 0xaf, offset 0x2bc0 0x2bc2: 0x0001, 0x2bc3: 0x0001, 0x2bc4: 0x0001, 0x2bc5: 0x0001, 0x2bc6: 0x0001, 0x2bc7: 0x0001, 0x2bca: 0x0001, 0x2bcb: 0x0001, 0x2bcc: 0x0001, 0x2bcd: 0x0001, 0x2bce: 0x0001, 0x2bcf: 0x0001, 0x2bd2: 0x0001, 0x2bd3: 0x0001, 0x2bd4: 0x0001, 0x2bd5: 0x0001, 0x2bd6: 0x0001, 0x2bd7: 0x0001, 0x2bda: 0x0001, 0x2bdb: 0x0001, 0x2bdc: 0x0001, 0x2bf9: 0x0040, 0x2bfa: 0x0040, 0x2bfb: 0x0040, // Block 0xb0, offset 0x2c00 0x2c00: 0x0001, 0x2c01: 0x0001, 0x2c02: 0x0001, 0x2c03: 0x0001, 0x2c04: 0x0001, 0x2c05: 0x0001, 0x2c06: 0x0001, 0x2c07: 0x0001, 0x2c08: 0x0001, 0x2c09: 0x0001, 0x2c0a: 0x0001, 0x2c0b: 0x0001, 0x2c0d: 0x0001, 0x2c0e: 0x0001, 0x2c0f: 0x0001, 0x2c10: 0x0001, 0x2c11: 0x0001, 0x2c12: 0x0001, 0x2c13: 0x0001, 0x2c14: 0x0001, 0x2c15: 0x0001, 0x2c16: 0x0001, 0x2c17: 0x0001, 0x2c18: 0x0001, 0x2c19: 0x0001, 0x2c1a: 0x0001, 0x2c1b: 0x0001, 0x2c1c: 0x0001, 0x2c1d: 0x0001, 0x2c1e: 0x0001, 0x2c1f: 0x0001, 0x2c20: 0x0001, 0x2c21: 0x0001, 0x2c22: 0x0001, 0x2c23: 0x0001, 0x2c24: 0x0001, 0x2c25: 0x0001, 0x2c26: 0x0001, 0x2c28: 0x0001, 0x2c29: 0x0001, 0x2c2a: 0x0001, 0x2c2b: 0x0001, 0x2c2c: 0x0001, 0x2c2d: 0x0001, 0x2c2e: 0x0001, 0x2c2f: 0x0001, 0x2c30: 0x0001, 0x2c31: 0x0001, 0x2c32: 0x0001, 0x2c33: 0x0001, 0x2c34: 0x0001, 0x2c35: 0x0001, 0x2c36: 0x0001, 0x2c37: 0x0001, 0x2c38: 0x0001, 0x2c39: 0x0001, 0x2c3a: 0x0001, 0x2c3c: 0x0001, 0x2c3d: 0x0001, 0x2c3f: 0x0001, // Block 0xb1, offset 0x2c40 0x2c40: 0x0001, 0x2c41: 0x0001, 0x2c42: 0x0001, 0x2c43: 0x0001, 0x2c44: 0x0001, 0x2c45: 0x0001, 0x2c46: 0x0001, 0x2c47: 0x0001, 0x2c48: 0x0001, 0x2c49: 0x0001, 0x2c4a: 0x0001, 0x2c4b: 0x0001, 0x2c4c: 0x0001, 0x2c4d: 0x0001, 0x2c50: 0x0001, 0x2c51: 0x0001, 0x2c52: 0x0001, 0x2c53: 0x0001, 0x2c54: 0x0001, 0x2c55: 0x0001, 0x2c56: 0x0001, 0x2c57: 0x0001, 0x2c58: 0x0001, 0x2c59: 0x0001, 0x2c5a: 0x0001, 0x2c5b: 0x0001, 0x2c5c: 0x0001, 0x2c5d: 0x0001, // Block 0xb2, offset 0x2c80 0x2c80: 0x0001, 0x2c81: 0x0001, 0x2c82: 0x0001, 0x2c83: 0x0001, 0x2c84: 0x0001, 0x2c85: 0x0001, 0x2c86: 0x0001, 0x2c87: 0x0001, 0x2c88: 0x0001, 0x2c89: 0x0001, 0x2c8a: 0x0001, 0x2c8b: 0x0001, 0x2c8c: 0x0001, 0x2c8d: 0x0001, 0x2c8e: 0x0001, 0x2c8f: 0x0001, 0x2c90: 0x0001, 0x2c91: 0x0001, 0x2c92: 0x0001, 0x2c93: 0x0001, 0x2c94: 0x0001, 0x2c95: 0x0001, 0x2c96: 0x0001, 0x2c97: 0x0001, 0x2c98: 0x0001, 0x2c99: 0x0001, 0x2c9a: 0x0001, 0x2c9b: 0x0001, 0x2c9c: 0x0001, 0x2c9d: 0x0001, 0x2c9e: 0x0001, 0x2c9f: 0x0001, 0x2ca0: 0x0001, 0x2ca1: 0x0001, 0x2ca2: 0x0001, 0x2ca3: 0x0001, 0x2ca4: 0x0001, 0x2ca5: 0x0001, 0x2ca6: 0x0001, 0x2ca7: 0x0001, 0x2ca8: 0x0001, 0x2ca9: 0x0001, 0x2caa: 0x0001, 0x2cab: 0x0001, 0x2cac: 0x0001, 0x2cad: 0x0001, 0x2cae: 0x0001, 0x2caf: 0x0001, 0x2cb0: 0x0001, 0x2cb1: 0x0001, 0x2cb2: 0x0001, 0x2cb3: 0x0001, 0x2cb4: 0x0001, 0x2cb5: 0x0001, 0x2cb6: 0x0001, 0x2cb7: 0x0001, 0x2cb8: 0x0001, 0x2cb9: 0x0001, 0x2cba: 0x0001, // Block 0xb3, offset 0x2cc0 0x2cc0: 0x0001, 0x2cc1: 0x0001, 0x2cc2: 0x0001, 0x2cc3: 0x0001, 0x2cc4: 0x0001, 0x2cc5: 0x0001, 0x2cc6: 0x0001, 0x2cc7: 0x0001, 0x2cc8: 0x0001, 0x2cc9: 0x0001, 0x2cca: 0x0001, 0x2ccb: 0x0001, 0x2ccc: 0x0001, 0x2ccd: 0x0001, 0x2cce: 0x0001, 0x2ccf: 0x0001, 0x2cd0: 0x0001, 0x2cd1: 0x0001, 0x2cd2: 0x0001, 0x2cd3: 0x0001, 0x2cd4: 0x0001, 0x2cd5: 0x0001, 0x2cd6: 0x0001, 0x2cd7: 0x0001, 0x2cd8: 0x0001, 0x2cd9: 0x0001, 0x2cda: 0x0001, 0x2cdb: 0x0001, 0x2cdc: 0x0001, 0x2cdd: 0x0001, 0x2cde: 0x0001, 0x2cdf: 0x0001, 0x2ce0: 0x0001, 0x2ce1: 0x0001, 0x2ce2: 0x0001, 0x2ce3: 0x0001, 0x2ce4: 0x0001, 0x2ce5: 0x0001, 0x2ce6: 0x0001, 0x2ce7: 0x0001, 0x2ce8: 0x0001, 0x2ce9: 0x0001, 0x2cea: 0x0001, 0x2ceb: 0x0001, 0x2cec: 0x0001, 0x2ced: 0x0001, 0x2cee: 0x0001, 0x2cef: 0x0001, 0x2cf0: 0x0001, 0x2cf1: 0x0001, 0x2cf2: 0x0001, 0x2cf3: 0x0001, 0x2cf4: 0x0001, // Block 0xb4, offset 0x2d00 0x2d3d: 0x0008, // Block 0xb5, offset 0x2d40 0x2d40: 0x0001, 0x2d41: 0x0001, 0x2d42: 0x0001, 0x2d43: 0x0001, 0x2d44: 0x0001, 0x2d45: 0x0001, 0x2d46: 0x0001, 0x2d47: 0x0001, 0x2d48: 0x0001, 0x2d49: 0x0001, 0x2d4a: 0x0001, 0x2d4b: 0x0001, 0x2d4c: 0x0001, 0x2d4d: 0x0001, 0x2d4e: 0x0001, 0x2d4f: 0x0001, 0x2d50: 0x0001, 0x2d51: 0x0001, 0x2d52: 0x0001, 0x2d53: 0x0001, 0x2d54: 0x0001, 0x2d55: 0x0001, 0x2d56: 0x0001, 0x2d57: 0x0001, 0x2d58: 0x0001, 0x2d59: 0x0001, 0x2d5a: 0x0001, 0x2d5b: 0x0001, 0x2d5c: 0x0001, 0x2d60: 0x0001, 0x2d61: 0x0001, 0x2d62: 0x0001, 0x2d63: 0x0001, 0x2d64: 0x0001, 0x2d65: 0x0001, 0x2d66: 0x0001, 0x2d67: 0x0001, 0x2d68: 0x0001, 0x2d69: 0x0001, 0x2d6a: 0x0001, 0x2d6b: 0x0001, 0x2d6c: 0x0001, 0x2d6d: 0x0001, 0x2d6e: 0x0001, 0x2d6f: 0x0001, 0x2d70: 0x0001, 0x2d71: 0x0001, 0x2d72: 0x0001, 0x2d73: 0x0001, 0x2d74: 0x0001, 0x2d75: 0x0001, 0x2d76: 0x0001, 0x2d77: 0x0001, 0x2d78: 0x0001, 0x2d79: 0x0001, 0x2d7a: 0x0001, 0x2d7b: 0x0001, 0x2d7c: 0x0001, 0x2d7d: 0x0001, 0x2d7e: 0x0001, 0x2d7f: 0x0001, // Block 0xb6, offset 0x2d80 0x2d80: 0x0001, 0x2d81: 0x0001, 0x2d82: 0x0001, 0x2d83: 0x0001, 0x2d84: 0x0001, 0x2d85: 0x0001, 0x2d86: 0x0001, 0x2d87: 0x0001, 0x2d88: 0x0001, 0x2d89: 0x0001, 0x2d8a: 0x0001, 0x2d8b: 0x0001, 0x2d8c: 0x0001, 0x2d8d: 0x0001, 0x2d8e: 0x0001, 0x2d8f: 0x0001, 0x2d90: 0x0001, 0x2da0: 0x0008, // Block 0xb7, offset 0x2dc0 0x2dc0: 0x0001, 0x2dc1: 0x0001, 0x2dc2: 0x0001, 0x2dc3: 0x0001, 0x2dc4: 0x0001, 0x2dc5: 0x0001, 0x2dc6: 0x0001, 0x2dc7: 0x0001, 0x2dc8: 0x0001, 0x2dc9: 0x0001, 0x2dca: 0x0001, 0x2dcb: 0x0001, 0x2dcc: 0x0001, 0x2dcd: 0x0001, 0x2dce: 0x0001, 0x2dcf: 0x0001, 0x2dd0: 0x0001, 0x2dd1: 0x0001, 0x2dd2: 0x0001, 0x2dd3: 0x0001, 0x2dd4: 0x0001, 0x2dd5: 0x0001, 0x2dd6: 0x0001, 0x2dd7: 0x0001, 0x2dd8: 0x0001, 0x2dd9: 0x0001, 0x2dda: 0x0001, 0x2ddb: 0x0001, 0x2ddc: 0x0001, 0x2ddd: 0x0001, 0x2dde: 0x0001, 0x2ddf: 0x0001, 0x2ded: 0x0001, 0x2dee: 0x0001, 0x2def: 0x0001, 0x2df0: 0x0001, 0x2df1: 0x0001, 0x2df2: 0x0001, 0x2df3: 0x0001, 0x2df4: 0x0001, 0x2df5: 0x0001, 0x2df6: 0x0001, 0x2df7: 0x0001, 0x2df8: 0x0001, 0x2df9: 0x0001, 0x2dfa: 0x0001, 0x2dfb: 0x0001, 0x2dfc: 0x0001, 0x2dfd: 0x0001, 0x2dfe: 0x0001, 0x2dff: 0x0001, // Block 0xb8, offset 0x2e00 0x2e00: 0x0001, 0x2e01: 0x0001, 0x2e02: 0x0001, 0x2e03: 0x0001, 0x2e04: 0x0001, 0x2e05: 0x0001, 0x2e06: 0x0001, 0x2e07: 0x0001, 0x2e08: 0x0001, 0x2e09: 0x0001, 0x2e0a: 0x0001, 0x2e10: 0x0001, 0x2e11: 0x0001, 0x2e12: 0x0001, 0x2e13: 0x0001, 0x2e14: 0x0001, 0x2e15: 0x0001, 0x2e16: 0x0001, 0x2e17: 0x0001, 0x2e18: 0x0001, 0x2e19: 0x0001, 0x2e1a: 0x0001, 0x2e1b: 0x0001, 0x2e1c: 0x0001, 0x2e1d: 0x0001, 0x2e1e: 0x0001, 0x2e1f: 0x0001, 0x2e20: 0x0001, 0x2e21: 0x0001, 0x2e22: 0x0001, 0x2e23: 0x0001, 0x2e24: 0x0001, 0x2e25: 0x0001, 0x2e26: 0x0001, 0x2e27: 0x0001, 0x2e28: 0x0001, 0x2e29: 0x0001, 0x2e2a: 0x0001, 0x2e2b: 0x0001, 0x2e2c: 0x0001, 0x2e2d: 0x0001, 0x2e2e: 0x0001, 0x2e2f: 0x0001, 0x2e30: 0x0001, 0x2e31: 0x0001, 0x2e32: 0x0001, 0x2e33: 0x0001, 0x2e34: 0x0001, 0x2e35: 0x0001, 0x2e36: 0x0008, 0x2e37: 0x0008, 0x2e38: 0x0008, 0x2e39: 0x0008, 0x2e3a: 0x0008, // Block 0xb9, offset 0x2e40 0x2e40: 0x0001, 0x2e41: 0x0001, 0x2e42: 0x0001, 0x2e43: 0x0001, 0x2e44: 0x0001, 0x2e45: 0x0001, 0x2e46: 0x0001, 0x2e47: 0x0001, 0x2e48: 0x0001, 0x2e49: 0x0001, 0x2e4a: 0x0001, 0x2e4b: 0x0001, 0x2e4c: 0x0001, 0x2e4d: 0x0001, 0x2e4e: 0x0001, 0x2e4f: 0x0001, 0x2e50: 0x0001, 0x2e51: 0x0001, 0x2e52: 0x0001, 0x2e53: 0x0001, 0x2e54: 0x0001, 0x2e55: 0x0001, 0x2e56: 0x0001, 0x2e57: 0x0001, 0x2e58: 0x0001, 0x2e59: 0x0001, 0x2e5a: 0x0001, 0x2e5b: 0x0001, 0x2e5c: 0x0001, 0x2e5d: 0x0001, 0x2e60: 0x0001, 0x2e61: 0x0001, 0x2e62: 0x0001, 0x2e63: 0x0001, 0x2e64: 0x0001, 0x2e65: 0x0001, 0x2e66: 0x0001, 0x2e67: 0x0001, 0x2e68: 0x0001, 0x2e69: 0x0001, 0x2e6a: 0x0001, 0x2e6b: 0x0001, 0x2e6c: 0x0001, 0x2e6d: 0x0001, 0x2e6e: 0x0001, 0x2e6f: 0x0001, 0x2e70: 0x0001, 0x2e71: 0x0001, 0x2e72: 0x0001, 0x2e73: 0x0001, 0x2e74: 0x0001, 0x2e75: 0x0001, 0x2e76: 0x0001, 0x2e77: 0x0001, 0x2e78: 0x0001, 0x2e79: 0x0001, 0x2e7a: 0x0001, 0x2e7b: 0x0001, 0x2e7c: 0x0001, 0x2e7d: 0x0001, 0x2e7e: 0x0001, 0x2e7f: 0x0001, // Block 0xba, offset 0x2e80 0x2e80: 0x0001, 0x2e81: 0x0001, 0x2e82: 0x0001, 0x2e83: 0x0001, 0x2e88: 0x0001, 0x2e89: 0x0001, 0x2e8a: 0x0001, 0x2e8b: 0x0001, 0x2e8c: 0x0001, 0x2e8d: 0x0001, 0x2e8e: 0x0001, 0x2e8f: 0x0001, 0x2e91: 0x0001, 0x2e92: 0x0001, 0x2e93: 0x0001, 0x2e94: 0x0001, 0x2e95: 0x0001, // Block 0xbb, offset 0x2ec0 0x2ec0: 0x0001, 0x2ec1: 0x0001, 0x2ec2: 0x0001, 0x2ec3: 0x0001, 0x2ec4: 0x0001, 0x2ec5: 0x0001, 0x2ec6: 0x0001, 0x2ec7: 0x0001, 0x2ec8: 0x0001, 0x2ec9: 0x0001, 0x2eca: 0x0001, 0x2ecb: 0x0001, 0x2ecc: 0x0001, 0x2ecd: 0x0001, 0x2ece: 0x0001, 0x2ecf: 0x0001, 0x2ed0: 0x0001, 0x2ed1: 0x0001, 0x2ed2: 0x0001, 0x2ed3: 0x0001, 0x2ed4: 0x0001, 0x2ed5: 0x0001, 0x2ed6: 0x0001, 0x2ed7: 0x0001, 0x2ed8: 0x0001, 0x2ed9: 0x0001, 0x2eda: 0x0001, 0x2edb: 0x0001, 0x2edc: 0x0001, 0x2edd: 0x0001, 0x2ee0: 0x4000, 0x2ee1: 0x4000, 0x2ee2: 0x4000, 0x2ee3: 0x4000, 0x2ee4: 0x4000, 0x2ee5: 0x4000, 0x2ee6: 0x4000, 0x2ee7: 0x4000, 0x2ee8: 0x4000, 0x2ee9: 0x4000, 0x2ef0: 0x0001, 0x2ef1: 0x0001, 0x2ef2: 0x0001, 0x2ef3: 0x0001, 0x2ef4: 0x0001, 0x2ef5: 0x0001, 0x2ef6: 0x0001, 0x2ef7: 0x0001, 0x2ef8: 0x0001, 0x2ef9: 0x0001, 0x2efa: 0x0001, 0x2efb: 0x0001, 0x2efc: 0x0001, 0x2efd: 0x0001, 0x2efe: 0x0001, 0x2eff: 0x0001, // Block 0xbc, offset 0x2f00 0x2f00: 0x0001, 0x2f01: 0x0001, 0x2f02: 0x0001, 0x2f03: 0x0001, 0x2f04: 0x0001, 0x2f05: 0x0001, 0x2f06: 0x0001, 0x2f07: 0x0001, 0x2f08: 0x0001, 0x2f09: 0x0001, 0x2f0a: 0x0001, 0x2f0b: 0x0001, 0x2f0c: 0x0001, 0x2f0d: 0x0001, 0x2f0e: 0x0001, 0x2f0f: 0x0001, 0x2f10: 0x0001, 0x2f11: 0x0001, 0x2f12: 0x0001, 0x2f13: 0x0001, 0x2f18: 0x0001, 0x2f19: 0x0001, 0x2f1a: 0x0001, 0x2f1b: 0x0001, 0x2f1c: 0x0001, 0x2f1d: 0x0001, 0x2f1e: 0x0001, 0x2f1f: 0x0001, 0x2f20: 0x0001, 0x2f21: 0x0001, 0x2f22: 0x0001, 0x2f23: 0x0001, 0x2f24: 0x0001, 0x2f25: 0x0001, 0x2f26: 0x0001, 0x2f27: 0x0001, 0x2f28: 0x0001, 0x2f29: 0x0001, 0x2f2a: 0x0001, 0x2f2b: 0x0001, 0x2f2c: 0x0001, 0x2f2d: 0x0001, 0x2f2e: 0x0001, 0x2f2f: 0x0001, 0x2f30: 0x0001, 0x2f31: 0x0001, 0x2f32: 0x0001, 0x2f33: 0x0001, 0x2f34: 0x0001, 0x2f35: 0x0001, 0x2f36: 0x0001, 0x2f37: 0x0001, 0x2f38: 0x0001, 0x2f39: 0x0001, 0x2f3a: 0x0001, 0x2f3b: 0x0001, // Block 0xbd, offset 0x2f40 0x2f40: 0x0001, 0x2f41: 0x0001, 0x2f42: 0x0001, 0x2f43: 0x0001, 0x2f44: 0x0001, 0x2f45: 0x0001, 0x2f46: 0x0001, 0x2f47: 0x0001, 0x2f48: 0x0001, 0x2f49: 0x0001, 0x2f4a: 0x0001, 0x2f4b: 0x0001, 0x2f4c: 0x0001, 0x2f4d: 0x0001, 0x2f4e: 0x0001, 0x2f4f: 0x0001, 0x2f50: 0x0001, 0x2f51: 0x0001, 0x2f52: 0x0001, 0x2f53: 0x0001, 0x2f54: 0x0001, 0x2f55: 0x0001, 0x2f56: 0x0001, 0x2f57: 0x0001, 0x2f58: 0x0001, 0x2f59: 0x0001, 0x2f5a: 0x0001, 0x2f5b: 0x0001, 0x2f5c: 0x0001, 0x2f5d: 0x0001, 0x2f5e: 0x0001, 0x2f5f: 0x0001, 0x2f60: 0x0001, 0x2f61: 0x0001, 0x2f62: 0x0001, 0x2f63: 0x0001, 0x2f64: 0x0001, 0x2f65: 0x0001, 0x2f66: 0x0001, 0x2f67: 0x0001, 0x2f70: 0x0001, 0x2f71: 0x0001, 0x2f72: 0x0001, 0x2f73: 0x0001, 0x2f74: 0x0001, 0x2f75: 0x0001, 0x2f76: 0x0001, 0x2f77: 0x0001, 0x2f78: 0x0001, 0x2f79: 0x0001, 0x2f7a: 0x0001, 0x2f7b: 0x0001, 0x2f7c: 0x0001, 0x2f7d: 0x0001, 0x2f7e: 0x0001, 0x2f7f: 0x0001, // Block 0xbe, offset 0x2f80 0x2f80: 0x0001, 0x2f81: 0x0001, 0x2f82: 0x0001, 0x2f83: 0x0001, 0x2f84: 0x0001, 0x2f85: 0x0001, 0x2f86: 0x0001, 0x2f87: 0x0001, 0x2f88: 0x0001, 0x2f89: 0x0001, 0x2f8a: 0x0001, 0x2f8b: 0x0001, 0x2f8c: 0x0001, 0x2f8d: 0x0001, 0x2f8e: 0x0001, 0x2f8f: 0x0001, 0x2f90: 0x0001, 0x2f91: 0x0001, 0x2f92: 0x0001, 0x2f93: 0x0001, 0x2f94: 0x0001, 0x2f95: 0x0001, 0x2f96: 0x0001, 0x2f97: 0x0001, 0x2f98: 0x0001, 0x2f99: 0x0001, 0x2f9a: 0x0001, 0x2f9b: 0x0001, 0x2f9c: 0x0001, 0x2f9d: 0x0001, 0x2f9e: 0x0001, 0x2f9f: 0x0001, 0x2fa0: 0x0001, 0x2fa1: 0x0001, 0x2fa2: 0x0001, 0x2fa3: 0x0001, 0x2fb0: 0x0001, 0x2fb1: 0x0001, 0x2fb2: 0x0001, 0x2fb3: 0x0001, 0x2fb4: 0x0001, 0x2fb5: 0x0001, 0x2fb6: 0x0001, 0x2fb7: 0x0001, 0x2fb8: 0x0001, 0x2fb9: 0x0001, 0x2fba: 0x0001, 0x2fbc: 0x0001, 0x2fbd: 0x0001, 0x2fbe: 0x0001, 0x2fbf: 0x0001, // Block 0xbf, offset 0x2fc0 0x2fc0: 0x0001, 0x2fc1: 0x0001, 0x2fc2: 0x0001, 0x2fc3: 0x0001, 0x2fc4: 0x0001, 0x2fc5: 0x0001, 0x2fc6: 0x0001, 0x2fc7: 0x0001, 0x2fc8: 0x0001, 0x2fc9: 0x0001, 0x2fca: 0x0001, 0x2fcc: 0x0001, 0x2fcd: 0x0001, 0x2fce: 0x0001, 0x2fcf: 0x0001, 0x2fd0: 0x0001, 0x2fd1: 0x0001, 0x2fd2: 0x0001, 0x2fd4: 0x0001, 0x2fd5: 0x0001, 0x2fd7: 0x0001, 0x2fd8: 0x0001, 0x2fd9: 0x0001, 0x2fda: 0x0001, 0x2fdb: 0x0001, 0x2fdc: 0x0001, 0x2fdd: 0x0001, 0x2fde: 0x0001, 0x2fdf: 0x0001, 0x2fe0: 0x0001, 0x2fe1: 0x0001, 0x2fe3: 0x0001, 0x2fe4: 0x0001, 0x2fe5: 0x0001, 0x2fe6: 0x0001, 0x2fe7: 0x0001, 0x2fe8: 0x0001, 0x2fe9: 0x0001, 0x2fea: 0x0001, 0x2feb: 0x0001, 0x2fec: 0x0001, 0x2fed: 0x0001, 0x2fee: 0x0001, 0x2fef: 0x0001, 0x2ff0: 0x0001, 0x2ff1: 0x0001, 0x2ff3: 0x0001, 0x2ff4: 0x0001, 0x2ff5: 0x0001, 0x2ff6: 0x0001, 0x2ff7: 0x0001, 0x2ff8: 0x0001, 0x2ff9: 0x0001, 0x2ffb: 0x0001, 0x2ffc: 0x0001, // Block 0xc0, offset 0x3000 0x3000: 0x0001, 0x3001: 0x0001, 0x3002: 0x0001, 0x3003: 0x0001, 0x3004: 0x0001, 0x3005: 0x0001, 0x3006: 0x0001, 0x3007: 0x0001, 0x3008: 0x0001, 0x3009: 0x0001, 0x300a: 0x0001, 0x300b: 0x0001, 0x300c: 0x0001, 0x300d: 0x0001, 0x300e: 0x0001, 0x300f: 0x0001, 0x3010: 0x0001, 0x3011: 0x0001, 0x3012: 0x0001, 0x3013: 0x0001, 0x3014: 0x0001, 0x3015: 0x0001, 0x3016: 0x0001, 0x3017: 0x0001, 0x3018: 0x0001, 0x3019: 0x0001, 0x301a: 0x0001, 0x301b: 0x0001, 0x301c: 0x0001, 0x301d: 0x0001, 0x301e: 0x0001, 0x301f: 0x0001, 0x3020: 0x0001, 0x3021: 0x0001, 0x3022: 0x0001, 0x3023: 0x0001, 0x3024: 0x0001, 0x3025: 0x0001, 0x3026: 0x0001, 0x3027: 0x0001, 0x3028: 0x0001, 0x3029: 0x0001, 0x302a: 0x0001, 0x302b: 0x0001, 0x302c: 0x0001, 0x302d: 0x0001, 0x302e: 0x0001, 0x302f: 0x0001, 0x3030: 0x0001, 0x3031: 0x0001, 0x3032: 0x0001, 0x3033: 0x0001, 0x3034: 0x0001, 0x3035: 0x0001, 0x3036: 0x0001, // Block 0xc1, offset 0x3040 0x3040: 0x0001, 0x3041: 0x0001, 0x3042: 0x0001, 0x3043: 0x0001, 0x3044: 0x0001, 0x3045: 0x0001, 0x3046: 0x0001, 0x3047: 0x0001, 0x3048: 0x0001, 0x3049: 0x0001, 0x304a: 0x0001, 0x304b: 0x0001, 0x304c: 0x0001, 0x304d: 0x0001, 0x304e: 0x0001, 0x304f: 0x0001, 0x3050: 0x0001, 0x3051: 0x0001, 0x3052: 0x0001, 0x3053: 0x0001, 0x3054: 0x0001, 0x3055: 0x0001, 0x3060: 0x0001, 0x3061: 0x0001, 0x3062: 0x0001, 0x3063: 0x0001, 0x3064: 0x0001, 0x3065: 0x0001, 0x3066: 0x0001, 0x3067: 0x0001, // Block 0xc2, offset 0x3080 0x3080: 0x0001, 0x3081: 0x0001, 0x3082: 0x0001, 0x3083: 0x0001, 0x3084: 0x0001, 0x3085: 0x0001, 0x3087: 0x0001, 0x3088: 0x0001, 0x3089: 0x0001, 0x308a: 0x0001, 0x308b: 0x0001, 0x308c: 0x0001, 0x308d: 0x0001, 0x308e: 0x0001, 0x308f: 0x0001, 0x3090: 0x0001, 0x3091: 0x0001, 0x3092: 0x0001, 0x3093: 0x0001, 0x3094: 0x0001, 0x3095: 0x0001, 0x3096: 0x0001, 0x3097: 0x0001, 0x3098: 0x0001, 0x3099: 0x0001, 0x309a: 0x0001, 0x309b: 0x0001, 0x309c: 0x0001, 0x309d: 0x0001, 0x309e: 0x0001, 0x309f: 0x0001, 0x30a0: 0x0001, 0x30a1: 0x0001, 0x30a2: 0x0001, 0x30a3: 0x0001, 0x30a4: 0x0001, 0x30a5: 0x0001, 0x30a6: 0x0001, 0x30a7: 0x0001, 0x30a8: 0x0001, 0x30a9: 0x0001, 0x30aa: 0x0001, 0x30ab: 0x0001, 0x30ac: 0x0001, 0x30ad: 0x0001, 0x30ae: 0x0001, 0x30af: 0x0001, 0x30b0: 0x0001, 0x30b2: 0x0001, 0x30b3: 0x0001, 0x30b4: 0x0001, 0x30b5: 0x0001, 0x30b6: 0x0001, 0x30b7: 0x0001, 0x30b8: 0x0001, 0x30b9: 0x0001, 0x30ba: 0x0001, // Block 0xc3, offset 0x30c0 0x30c0: 0x0001, 0x30c1: 0x0001, 0x30c2: 0x0001, 0x30c3: 0x0001, 0x30c4: 0x0001, 0x30c5: 0x0001, 0x30c8: 0x0001, 0x30ca: 0x0001, 0x30cb: 0x0001, 0x30cc: 0x0001, 0x30cd: 0x0001, 0x30ce: 0x0001, 0x30cf: 0x0001, 0x30d0: 0x0001, 0x30d1: 0x0001, 0x30d2: 0x0001, 0x30d3: 0x0001, 0x30d4: 0x0001, 0x30d5: 0x0001, 0x30d6: 0x0001, 0x30d7: 0x0001, 0x30d8: 0x0001, 0x30d9: 0x0001, 0x30da: 0x0001, 0x30db: 0x0001, 0x30dc: 0x0001, 0x30dd: 0x0001, 0x30de: 0x0001, 0x30df: 0x0001, 0x30e0: 0x0001, 0x30e1: 0x0001, 0x30e2: 0x0001, 0x30e3: 0x0001, 0x30e4: 0x0001, 0x30e5: 0x0001, 0x30e6: 0x0001, 0x30e7: 0x0001, 0x30e8: 0x0001, 0x30e9: 0x0001, 0x30ea: 0x0001, 0x30eb: 0x0001, 0x30ec: 0x0001, 0x30ed: 0x0001, 0x30ee: 0x0001, 0x30ef: 0x0001, 0x30f0: 0x0001, 0x30f1: 0x0001, 0x30f2: 0x0001, 0x30f3: 0x0001, 0x30f4: 0x0001, 0x30f5: 0x0001, 0x30f7: 0x0001, 0x30f8: 0x0001, 0x30fc: 0x0001, 0x30ff: 0x0001, // Block 0xc4, offset 0x3100 0x3100: 0x0001, 0x3101: 0x0001, 0x3102: 0x0001, 0x3103: 0x0001, 0x3104: 0x0001, 0x3105: 0x0001, 0x3106: 0x0001, 0x3107: 0x0001, 0x3108: 0x0001, 0x3109: 0x0001, 0x310a: 0x0001, 0x310b: 0x0001, 0x310c: 0x0001, 0x310d: 0x0001, 0x310e: 0x0001, 0x310f: 0x0001, 0x3110: 0x0001, 0x3111: 0x0001, 0x3112: 0x0001, 0x3113: 0x0001, 0x3114: 0x0001, 0x3115: 0x0001, 0x3120: 0x0001, 0x3121: 0x0001, 0x3122: 0x0001, 0x3123: 0x0001, 0x3124: 0x0001, 0x3125: 0x0001, 0x3126: 0x0001, 0x3127: 0x0001, 0x3128: 0x0001, 0x3129: 0x0001, 0x312a: 0x0001, 0x312b: 0x0001, 0x312c: 0x0001, 0x312d: 0x0001, 0x312e: 0x0001, 0x312f: 0x0001, 0x3130: 0x0001, 0x3131: 0x0001, 0x3132: 0x0001, 0x3133: 0x0001, 0x3134: 0x0001, 0x3135: 0x0001, 0x3136: 0x0001, // Block 0xc5, offset 0x3140 0x3140: 0x0001, 0x3141: 0x0001, 0x3142: 0x0001, 0x3143: 0x0001, 0x3144: 0x0001, 0x3145: 0x0001, 0x3146: 0x0001, 0x3147: 0x0001, 0x3148: 0x0001, 0x3149: 0x0001, 0x314a: 0x0001, 0x314b: 0x0001, 0x314c: 0x0001, 0x314d: 0x0001, 0x314e: 0x0001, 0x314f: 0x0001, 0x3150: 0x0001, 0x3151: 0x0001, 0x3152: 0x0001, 0x3153: 0x0001, 0x3154: 0x0001, 0x3155: 0x0001, 0x3156: 0x0001, 0x3157: 0x0001, 0x3158: 0x0001, 0x3159: 0x0001, 0x315a: 0x0001, 0x315b: 0x0001, 0x315c: 0x0001, 0x315d: 0x0001, 0x315e: 0x0001, // Block 0xc6, offset 0x3180 0x31a0: 0x0001, 0x31a1: 0x0001, 0x31a2: 0x0001, 0x31a3: 0x0001, 0x31a4: 0x0001, 0x31a5: 0x0001, 0x31a6: 0x0001, 0x31a7: 0x0001, 0x31a8: 0x0001, 0x31a9: 0x0001, 0x31aa: 0x0001, 0x31ab: 0x0001, 0x31ac: 0x0001, 0x31ad: 0x0001, 0x31ae: 0x0001, 0x31af: 0x0001, 0x31b0: 0x0001, 0x31b1: 0x0001, 0x31b2: 0x0001, 0x31b4: 0x0001, 0x31b5: 0x0001, // Block 0xc7, offset 0x31c0 0x31c0: 0x0001, 0x31c1: 0x0001, 0x31c2: 0x0001, 0x31c3: 0x0001, 0x31c4: 0x0001, 0x31c5: 0x0001, 0x31c6: 0x0001, 0x31c7: 0x0001, 0x31c8: 0x0001, 0x31c9: 0x0001, 0x31ca: 0x0001, 0x31cb: 0x0001, 0x31cc: 0x0001, 0x31cd: 0x0001, 0x31ce: 0x0001, 0x31cf: 0x0001, 0x31d0: 0x0001, 0x31d1: 0x0001, 0x31d2: 0x0001, 0x31d3: 0x0001, 0x31d4: 0x0001, 0x31d5: 0x0001, 0x31e0: 0x0001, 0x31e1: 0x0001, 0x31e2: 0x0001, 0x31e3: 0x0001, 0x31e4: 0x0001, 0x31e5: 0x0001, 0x31e6: 0x0001, 0x31e7: 0x0001, 0x31e8: 0x0001, 0x31e9: 0x0001, 0x31ea: 0x0001, 0x31eb: 0x0001, 0x31ec: 0x0001, 0x31ed: 0x0001, 0x31ee: 0x0001, 0x31ef: 0x0001, 0x31f0: 0x0001, 0x31f1: 0x0001, 0x31f2: 0x0001, 0x31f3: 0x0001, 0x31f4: 0x0001, 0x31f5: 0x0001, 0x31f6: 0x0001, 0x31f7: 0x0001, 0x31f8: 0x0001, 0x31f9: 0x0001, // Block 0xc8, offset 0x3200 0x3200: 0x0001, 0x3201: 0x0001, 0x3202: 0x0001, 0x3203: 0x0001, 0x3204: 0x0001, 0x3205: 0x0001, 0x3206: 0x0001, 0x3207: 0x0001, 0x3208: 0x0001, 0x3209: 0x0001, 0x320a: 0x0001, 0x320b: 0x0001, 0x320c: 0x0001, 0x320d: 0x0001, 0x320e: 0x0001, 0x320f: 0x0001, 0x3210: 0x0001, 0x3211: 0x0001, 0x3212: 0x0001, 0x3213: 0x0001, 0x3214: 0x0001, 0x3215: 0x0001, 0x3216: 0x0001, 0x3217: 0x0001, 0x3218: 0x0001, 0x3219: 0x0001, // Block 0xc9, offset 0x3240 0x3240: 0x0001, 0x3241: 0x0001, 0x3242: 0x0001, 0x3243: 0x0001, 0x3244: 0x0001, 0x3245: 0x0001, 0x3246: 0x0001, 0x3247: 0x0001, 0x3248: 0x0001, 0x3249: 0x0001, 0x324a: 0x0001, 0x324b: 0x0001, 0x324c: 0x0001, 0x324d: 0x0001, 0x324e: 0x0001, 0x324f: 0x0001, 0x3250: 0x0001, 0x3251: 0x0001, 0x3252: 0x0001, 0x3253: 0x0001, 0x3254: 0x0001, 0x3255: 0x0001, 0x3256: 0x0001, 0x3257: 0x0001, 0x3258: 0x0001, 0x3259: 0x0001, 0x325a: 0x0001, 0x325b: 0x0001, 0x325c: 0x0001, 0x325d: 0x0001, 0x325e: 0x0001, 0x325f: 0x0001, 0x3260: 0x0001, 0x3261: 0x0001, 0x3262: 0x0001, 0x3263: 0x0001, 0x3264: 0x0001, 0x3265: 0x0001, 0x3266: 0x0001, 0x3267: 0x0001, 0x3268: 0x0001, 0x3269: 0x0001, 0x326a: 0x0001, 0x326b: 0x0001, 0x326c: 0x0001, 0x326d: 0x0001, 0x326e: 0x0001, 0x326f: 0x0001, 0x3270: 0x0001, 0x3271: 0x0001, 0x3272: 0x0001, 0x3273: 0x0001, 0x3274: 0x0001, 0x3275: 0x0001, 0x3276: 0x0001, 0x3277: 0x0001, 0x327e: 0x0001, 0x327f: 0x0001, // Block 0xca, offset 0x3280 0x3280: 0x0001, 0x3281: 0x0008, 0x3282: 0x0008, 0x3283: 0x0008, 0x3285: 0x0008, 0x3286: 0x0008, 0x328c: 0x0008, 0x328d: 0x0008, 0x328e: 0x0008, 0x328f: 0x0008, 0x3290: 0x0001, 0x3291: 0x0001, 0x3292: 0x0001, 0x3293: 0x0001, 0x3295: 0x0001, 0x3296: 0x0001, 0x3297: 0x0001, 0x3299: 0x0001, 0x329a: 0x0001, 0x329b: 0x0001, 0x329c: 0x0001, 0x329d: 0x0001, 0x329e: 0x0001, 0x329f: 0x0001, 0x32a0: 0x0001, 0x32a1: 0x0001, 0x32a2: 0x0001, 0x32a3: 0x0001, 0x32a4: 0x0001, 0x32a5: 0x0001, 0x32a6: 0x0001, 0x32a7: 0x0001, 0x32a8: 0x0001, 0x32a9: 0x0001, 0x32aa: 0x0001, 0x32ab: 0x0001, 0x32ac: 0x0001, 0x32ad: 0x0001, 0x32ae: 0x0001, 0x32af: 0x0001, 0x32b0: 0x0001, 0x32b1: 0x0001, 0x32b2: 0x0001, 0x32b3: 0x0001, 0x32b4: 0x0001, 0x32b5: 0x0001, 0x32b8: 0x0008, 0x32b9: 0x0008, 0x32ba: 0x0008, 0x32bf: 0x0008, // Block 0xcb, offset 0x32c0 0x32e0: 0x0001, 0x32e1: 0x0001, 0x32e2: 0x0001, 0x32e3: 0x0001, 0x32e4: 0x0001, 0x32e5: 0x0001, 0x32e6: 0x0001, 0x32e7: 0x0001, 0x32e8: 0x0001, 0x32e9: 0x0001, 0x32ea: 0x0001, 0x32eb: 0x0001, 0x32ec: 0x0001, 0x32ed: 0x0001, 0x32ee: 0x0001, 0x32ef: 0x0001, 0x32f0: 0x0001, 0x32f1: 0x0001, 0x32f2: 0x0001, 0x32f3: 0x0001, 0x32f4: 0x0001, 0x32f5: 0x0001, 0x32f6: 0x0001, 0x32f7: 0x0001, 0x32f8: 0x0001, 0x32f9: 0x0001, 0x32fa: 0x0001, 0x32fb: 0x0001, 0x32fc: 0x0001, // Block 0xcc, offset 0x3300 0x3300: 0x0001, 0x3301: 0x0001, 0x3302: 0x0001, 0x3303: 0x0001, 0x3304: 0x0001, 0x3305: 0x0001, 0x3306: 0x0001, 0x3307: 0x0001, 0x3308: 0x0001, 0x3309: 0x0001, 0x330a: 0x0001, 0x330b: 0x0001, 0x330c: 0x0001, 0x330d: 0x0001, 0x330e: 0x0001, 0x330f: 0x0001, 0x3310: 0x0001, 0x3311: 0x0001, 0x3312: 0x0001, 0x3313: 0x0001, 0x3314: 0x0001, 0x3315: 0x0001, 0x3316: 0x0001, 0x3317: 0x0001, 0x3318: 0x0001, 0x3319: 0x0001, 0x331a: 0x0001, 0x331b: 0x0001, 0x331c: 0x0001, // Block 0xcd, offset 0x3340 0x3340: 0x0001, 0x3341: 0x0001, 0x3342: 0x0001, 0x3343: 0x0001, 0x3344: 0x0001, 0x3345: 0x0001, 0x3346: 0x0001, 0x3347: 0x0001, 0x3349: 0x0001, 0x334a: 0x0001, 0x334b: 0x0001, 0x334c: 0x0001, 0x334d: 0x0001, 0x334e: 0x0001, 0x334f: 0x0001, 0x3350: 0x0001, 0x3351: 0x0001, 0x3352: 0x0001, 0x3353: 0x0001, 0x3354: 0x0001, 0x3355: 0x0001, 0x3356: 0x0001, 0x3357: 0x0001, 0x3358: 0x0001, 0x3359: 0x0001, 0x335a: 0x0001, 0x335b: 0x0001, 0x335c: 0x0001, 0x335d: 0x0001, 0x335e: 0x0001, 0x335f: 0x0001, 0x3360: 0x0001, 0x3361: 0x0001, 0x3362: 0x0001, 0x3363: 0x0001, 0x3364: 0x0001, 0x3365: 0x0008, 0x3366: 0x0008, // Block 0xce, offset 0x3380 0x3380: 0x0001, 0x3381: 0x0001, 0x3382: 0x0001, 0x3383: 0x0001, 0x3384: 0x0001, 0x3385: 0x0001, 0x3386: 0x0001, 0x3387: 0x0001, 0x3388: 0x0001, 0x3389: 0x0001, 0x338a: 0x0001, 0x338b: 0x0001, 0x338c: 0x0001, 0x338d: 0x0001, 0x338e: 0x0001, 0x338f: 0x0001, 0x3390: 0x0001, 0x3391: 0x0001, 0x3392: 0x0001, 0x3393: 0x0001, 0x3394: 0x0001, 0x3395: 0x0001, 0x33a0: 0x0001, 0x33a1: 0x0001, 0x33a2: 0x0001, 0x33a3: 0x0001, 0x33a4: 0x0001, 0x33a5: 0x0001, 0x33a6: 0x0001, 0x33a7: 0x0001, 0x33a8: 0x0001, 0x33a9: 0x0001, 0x33aa: 0x0001, 0x33ab: 0x0001, 0x33ac: 0x0001, 0x33ad: 0x0001, 0x33ae: 0x0001, 0x33af: 0x0001, 0x33b0: 0x0001, 0x33b1: 0x0001, 0x33b2: 0x0001, // Block 0xcf, offset 0x33c0 0x33c0: 0x0001, 0x33c1: 0x0001, 0x33c2: 0x0001, 0x33c3: 0x0001, 0x33c4: 0x0001, 0x33c5: 0x0001, 0x33c6: 0x0001, 0x33c7: 0x0001, 0x33c8: 0x0001, 0x33c9: 0x0001, 0x33ca: 0x0001, 0x33cb: 0x0001, 0x33cc: 0x0001, 0x33cd: 0x0001, 0x33ce: 0x0001, 0x33cf: 0x0001, 0x33d0: 0x0001, 0x33d1: 0x0001, // Block 0xd0, offset 0x3400 0x3400: 0x0001, 0x3401: 0x0001, 0x3402: 0x0001, 0x3403: 0x0001, 0x3404: 0x0001, 0x3405: 0x0001, 0x3406: 0x0001, 0x3407: 0x0001, 0x3408: 0x0001, // Block 0xd1, offset 0x3440 0x3440: 0x0001, 0x3441: 0x0001, 0x3442: 0x0001, 0x3443: 0x0001, 0x3444: 0x0001, 0x3445: 0x0001, 0x3446: 0x0001, 0x3447: 0x0001, 0x3448: 0x0001, 0x3449: 0x0001, 0x344a: 0x0001, 0x344b: 0x0001, 0x344c: 0x0001, 0x344d: 0x0001, 0x344e: 0x0001, 0x344f: 0x0001, 0x3450: 0x0001, 0x3451: 0x0001, 0x3452: 0x0001, 0x3453: 0x0001, 0x3454: 0x0001, 0x3455: 0x0001, 0x3456: 0x0001, 0x3457: 0x0001, 0x3458: 0x0001, 0x3459: 0x0001, 0x345a: 0x0001, 0x345b: 0x0001, 0x345c: 0x0001, 0x345d: 0x0001, 0x345e: 0x0001, 0x345f: 0x0001, 0x3460: 0x0001, 0x3461: 0x0001, 0x3462: 0x0001, 0x3463: 0x0001, 0x3464: 0x0001, 0x3465: 0x0001, 0x3466: 0x0001, 0x3467: 0x0001, 0x3468: 0x0001, 0x3469: 0x0001, 0x346a: 0x0001, 0x346b: 0x0001, 0x346c: 0x0001, 0x346d: 0x0001, 0x346e: 0x0001, 0x346f: 0x0001, 0x3470: 0x0001, 0x3471: 0x0001, 0x3472: 0x0001, // Block 0xd2, offset 0x3480 0x3480: 0x0001, 0x3481: 0x0001, 0x3482: 0x0001, 0x3483: 0x0001, 0x3484: 0x0001, 0x3485: 0x0001, 0x3486: 0x0001, 0x3487: 0x0001, 0x3488: 0x0001, 0x3489: 0x0001, 0x348a: 0x0001, 0x348b: 0x0001, 0x348c: 0x0001, 0x348d: 0x0001, 0x348e: 0x0001, 0x348f: 0x0001, 0x3490: 0x0001, 0x3491: 0x0001, 0x3492: 0x0001, 0x3493: 0x0001, 0x3494: 0x0001, 0x3495: 0x0001, 0x3496: 0x0001, 0x3497: 0x0001, 0x3498: 0x0001, 0x3499: 0x0001, 0x349a: 0x0001, 0x349b: 0x0001, 0x349c: 0x0001, 0x349d: 0x0001, 0x349e: 0x0001, 0x349f: 0x0001, 0x34a0: 0x0001, 0x34a1: 0x0001, 0x34a2: 0x0001, 0x34a3: 0x0001, 0x34a4: 0x0008, 0x34a5: 0x0008, 0x34a6: 0x0008, 0x34a7: 0x0008, 0x34b0: 0x4000, 0x34b1: 0x4000, 0x34b2: 0x4000, 0x34b3: 0x4000, 0x34b4: 0x4000, 0x34b5: 0x4000, 0x34b6: 0x4000, 0x34b7: 0x4000, 0x34b8: 0x4000, 0x34b9: 0x4000, // Block 0xd3, offset 0x34c0 0x34c0: 0x4000, 0x34c1: 0x4000, 0x34c2: 0x4000, 0x34c3: 0x4000, 0x34c4: 0x4000, 0x34c5: 0x4000, 0x34c6: 0x4000, 0x34c7: 0x4000, 0x34c8: 0x4000, 0x34c9: 0x4000, 0x34ca: 0x0001, 0x34cb: 0x0001, 0x34cc: 0x0001, 0x34cd: 0x0001, 0x34ce: 0x0001, 0x34cf: 0x0001, 0x34d0: 0x0001, 0x34d1: 0x0001, 0x34d2: 0x0001, 0x34d3: 0x0001, 0x34d4: 0x0001, 0x34d5: 0x0001, 0x34d6: 0x0001, 0x34d7: 0x0001, 0x34d8: 0x0001, 0x34d9: 0x0001, 0x34da: 0x0001, 0x34db: 0x0001, 0x34dc: 0x0001, 0x34dd: 0x0001, 0x34de: 0x0001, 0x34df: 0x0001, 0x34e0: 0x0001, 0x34e1: 0x0001, 0x34e2: 0x0001, 0x34e3: 0x0001, 0x34e4: 0x0001, 0x34e5: 0x0001, 0x34e9: 0x0008, 0x34ea: 0x0008, 0x34eb: 0x0008, 0x34ec: 0x0008, 0x34ed: 0x0008, 0x34ef: 0x0001, 0x34f0: 0x0001, 0x34f1: 0x0001, 0x34f2: 0x0001, 0x34f3: 0x0001, 0x34f4: 0x0001, 0x34f5: 0x0001, 0x34f6: 0x0001, 0x34f7: 0x0001, 0x34f8: 0x0001, 0x34f9: 0x0001, 0x34fa: 0x0001, 0x34fb: 0x0001, 0x34fc: 0x0001, 0x34fd: 0x0001, 0x34fe: 0x0001, 0x34ff: 0x0001, // Block 0xd4, offset 0x3500 0x3500: 0x0001, 0x3501: 0x0001, 0x3502: 0x0001, 0x3503: 0x0001, 0x3504: 0x0001, 0x3505: 0x0001, // Block 0xd5, offset 0x3540 0x3540: 0x0001, 0x3541: 0x0001, 0x3542: 0x0001, 0x3543: 0x0001, 0x3544: 0x0001, 0x3545: 0x0001, 0x3546: 0x0001, 0x3547: 0x0001, 0x3548: 0x0001, 0x3549: 0x0001, 0x354a: 0x0001, 0x354b: 0x0001, 0x354c: 0x0001, 0x354d: 0x0001, 0x354e: 0x0001, 0x354f: 0x0001, 0x3550: 0x0001, 0x3551: 0x0001, 0x3552: 0x0001, 0x3553: 0x0001, 0x3554: 0x0001, 0x3555: 0x0001, 0x3556: 0x0001, 0x3557: 0x0001, 0x3558: 0x0001, 0x3559: 0x0001, 0x355a: 0x0001, 0x355b: 0x0001, 0x355c: 0x0001, 0x355d: 0x0001, 0x355e: 0x0001, 0x355f: 0x0001, 0x3560: 0x0001, 0x3561: 0x0001, 0x3562: 0x0001, 0x3563: 0x0001, 0x3564: 0x0001, 0x3565: 0x0001, 0x3566: 0x0001, 0x3567: 0x0001, 0x3568: 0x0001, 0x3569: 0x0001, 0x356b: 0x0008, 0x356c: 0x0008, 0x3570: 0x0001, 0x3571: 0x0001, // Block 0xd6, offset 0x3580 0x3582: 0x0001, 0x3583: 0x0001, 0x3584: 0x0001, 0x3585: 0x0001, 0x3586: 0x0001, 0x3587: 0x0001, 0x35ba: 0x0008, 0x35bb: 0x0008, 0x35bc: 0x0008, 0x35bd: 0x0008, 0x35be: 0x0008, 0x35bf: 0x0008, // Block 0xd7, offset 0x35c0 0x35c0: 0x0001, 0x35c1: 0x0001, 0x35c2: 0x0001, 0x35c3: 0x0001, 0x35c4: 0x0001, 0x35c5: 0x0001, 0x35c6: 0x0001, 0x35c7: 0x0001, 0x35c8: 0x0001, 0x35c9: 0x0001, 0x35ca: 0x0001, 0x35cb: 0x0001, 0x35cc: 0x0001, 0x35cd: 0x0001, 0x35ce: 0x0001, 0x35cf: 0x0001, 0x35d0: 0x0001, 0x35d1: 0x0001, 0x35d2: 0x0001, 0x35d3: 0x0001, 0x35d4: 0x0001, 0x35d5: 0x0001, 0x35d6: 0x0001, 0x35d7: 0x0001, 0x35d8: 0x0001, 0x35d9: 0x0001, 0x35da: 0x0001, 0x35db: 0x0001, 0x35dc: 0x0001, 0x35e7: 0x0001, 0x35f0: 0x0001, 0x35f1: 0x0001, 0x35f2: 0x0001, 0x35f3: 0x0001, 0x35f4: 0x0001, 0x35f5: 0x0001, 0x35f6: 0x0001, 0x35f7: 0x0001, 0x35f8: 0x0001, 0x35f9: 0x0001, 0x35fa: 0x0001, 0x35fb: 0x0001, 0x35fc: 0x0001, 0x35fd: 0x0001, 0x35fe: 0x0001, 0x35ff: 0x0001, // Block 0xd8, offset 0x3600 0x3600: 0x0001, 0x3601: 0x0001, 0x3602: 0x0001, 0x3603: 0x0001, 0x3604: 0x0001, 0x3605: 0x0001, 0x3606: 0x0008, 0x3607: 0x0008, 0x3608: 0x0008, 0x3609: 0x0008, 0x360a: 0x0008, 0x360b: 0x0008, 0x360c: 0x0008, 0x360d: 0x0008, 0x360e: 0x0008, 0x360f: 0x0008, 0x3610: 0x0008, 0x3630: 0x0001, 0x3631: 0x0001, 0x3632: 0x0001, 0x3633: 0x0001, 0x3634: 0x0001, 0x3635: 0x0001, 0x3636: 0x0001, 0x3637: 0x0001, 0x3638: 0x0001, 0x3639: 0x0001, 0x363a: 0x0001, 0x363b: 0x0001, 0x363c: 0x0001, 0x363d: 0x0001, 0x363e: 0x0001, 0x363f: 0x0001, // Block 0xd9, offset 0x3640 0x3640: 0x0001, 0x3641: 0x0001, 0x3642: 0x0008, 0x3643: 0x0008, 0x3644: 0x0008, 0x3645: 0x0008, 0x3670: 0x0001, 0x3671: 0x0001, 0x3672: 0x0001, 0x3673: 0x0001, 0x3674: 0x0001, 0x3675: 0x0001, 0x3676: 0x0001, 0x3677: 0x0001, 0x3678: 0x0001, 0x3679: 0x0001, 0x367a: 0x0001, 0x367b: 0x0001, 0x367c: 0x0001, 0x367d: 0x0001, 0x367e: 0x0001, 0x367f: 0x0001, // Block 0xda, offset 0x3680 0x3680: 0x0001, 0x3681: 0x0001, 0x3682: 0x0001, 0x3683: 0x0001, 0x3684: 0x0001, 0x36a0: 0x0001, 0x36a1: 0x0001, 0x36a2: 0x0001, 0x36a3: 0x0001, 0x36a4: 0x0001, 0x36a5: 0x0001, 0x36a6: 0x0001, 0x36a7: 0x0001, 0x36a8: 0x0001, 0x36a9: 0x0001, 0x36aa: 0x0001, 0x36ab: 0x0001, 0x36ac: 0x0001, 0x36ad: 0x0001, 0x36ae: 0x0001, 0x36af: 0x0001, 0x36b0: 0x0001, 0x36b1: 0x0001, 0x36b2: 0x0001, 0x36b3: 0x0001, 0x36b4: 0x0001, 0x36b5: 0x0001, 0x36b6: 0x0001, // Block 0xdb, offset 0x36c0 0x36c0: 0x0008, 0x36c1: 0x0008, 0x36c2: 0x0008, 0x36c3: 0x0001, 0x36c4: 0x0001, 0x36c5: 0x0001, 0x36c6: 0x0001, 0x36c7: 0x0001, 0x36c8: 0x0001, 0x36c9: 0x0001, 0x36ca: 0x0001, 0x36cb: 0x0001, 0x36cc: 0x0001, 0x36cd: 0x0001, 0x36ce: 0x0001, 0x36cf: 0x0001, 0x36d0: 0x0001, 0x36d1: 0x0001, 0x36d2: 0x0001, 0x36d3: 0x0001, 0x36d4: 0x0001, 0x36d5: 0x0001, 0x36d6: 0x0001, 0x36d7: 0x0001, 0x36d8: 0x0001, 0x36d9: 0x0001, 0x36da: 0x0001, 0x36db: 0x0001, 0x36dc: 0x0001, 0x36dd: 0x0001, 0x36de: 0x0001, 0x36df: 0x0001, 0x36e0: 0x0001, 0x36e1: 0x0001, 0x36e2: 0x0001, 0x36e3: 0x0001, 0x36e4: 0x0001, 0x36e5: 0x0001, 0x36e6: 0x0001, 0x36e7: 0x0001, 0x36e8: 0x0001, 0x36e9: 0x0001, 0x36ea: 0x0001, 0x36eb: 0x0001, 0x36ec: 0x0001, 0x36ed: 0x0001, 0x36ee: 0x0001, 0x36ef: 0x0001, 0x36f0: 0x0001, 0x36f1: 0x0001, 0x36f2: 0x0001, 0x36f3: 0x0001, 0x36f4: 0x0001, 0x36f5: 0x0001, 0x36f6: 0x0001, 0x36f7: 0x0001, 0x36f8: 0x0008, 0x36f9: 0x0008, 0x36fa: 0x0008, 0x36fb: 0x0008, 0x36fc: 0x0008, 0x36fd: 0x0008, 0x36fe: 0x0008, 0x36ff: 0x0008, // Block 0xdc, offset 0x3700 0x3700: 0x0008, 0x3701: 0x0008, 0x3702: 0x0008, 0x3703: 0x0008, 0x3704: 0x0008, 0x3705: 0x0008, 0x3706: 0x0008, 0x3726: 0x4000, 0x3727: 0x4000, 0x3728: 0x4000, 0x3729: 0x4000, 0x372a: 0x4000, 0x372b: 0x4000, 0x372c: 0x4000, 0x372d: 0x4000, 0x372e: 0x4000, 0x372f: 0x4000, 0x3730: 0x0008, 0x3731: 0x0001, 0x3732: 0x0001, 0x3733: 0x0008, 0x3734: 0x0008, 0x3735: 0x0001, 0x373f: 0x0008, // Block 0xdd, offset 0x3740 0x3740: 0x0008, 0x3741: 0x0008, 0x3742: 0x0008, 0x3743: 0x0001, 0x3744: 0x0001, 0x3745: 0x0001, 0x3746: 0x0001, 0x3747: 0x0001, 0x3748: 0x0001, 0x3749: 0x0001, 0x374a: 0x0001, 0x374b: 0x0001, 0x374c: 0x0001, 0x374d: 0x0001, 0x374e: 0x0001, 0x374f: 0x0001, 0x3750: 0x0001, 0x3751: 0x0001, 0x3752: 0x0001, 0x3753: 0x0001, 0x3754: 0x0001, 0x3755: 0x0001, 0x3756: 0x0001, 0x3757: 0x0001, 0x3758: 0x0001, 0x3759: 0x0001, 0x375a: 0x0001, 0x375b: 0x0001, 0x375c: 0x0001, 0x375d: 0x0001, 0x375e: 0x0001, 0x375f: 0x0001, 0x3760: 0x0001, 0x3761: 0x0001, 0x3762: 0x0001, 0x3763: 0x0001, 0x3764: 0x0001, 0x3765: 0x0001, 0x3766: 0x0001, 0x3767: 0x0001, 0x3768: 0x0001, 0x3769: 0x0001, 0x376a: 0x0001, 0x376b: 0x0001, 0x376c: 0x0001, 0x376d: 0x0001, 0x376e: 0x0001, 0x376f: 0x0001, 0x3770: 0x0008, 0x3771: 0x0008, 0x3772: 0x0008, 0x3773: 0x0008, 0x3774: 0x0008, 0x3775: 0x0008, 0x3776: 0x0008, 0x3777: 0x0008, 0x3778: 0x0008, 0x3779: 0x0008, 0x377a: 0x0008, 0x377d: 0x4000, // Block 0xde, offset 0x3780 0x3782: 0x0008, 0x378d: 0x4000, 0x3790: 0x0001, 0x3791: 0x0001, 0x3792: 0x0001, 0x3793: 0x0001, 0x3794: 0x0001, 0x3795: 0x0001, 0x3796: 0x0001, 0x3797: 0x0001, 0x3798: 0x0001, 0x3799: 0x0001, 0x379a: 0x0001, 0x379b: 0x0001, 0x379c: 0x0001, 0x379d: 0x0001, 0x379e: 0x0001, 0x379f: 0x0001, 0x37a0: 0x0001, 0x37a1: 0x0001, 0x37a2: 0x0001, 0x37a3: 0x0001, 0x37a4: 0x0001, 0x37a5: 0x0001, 0x37a6: 0x0001, 0x37a7: 0x0001, 0x37a8: 0x0001, 0x37b0: 0x4000, 0x37b1: 0x4000, 0x37b2: 0x4000, 0x37b3: 0x4000, 0x37b4: 0x4000, 0x37b5: 0x4000, 0x37b6: 0x4000, 0x37b7: 0x4000, 0x37b8: 0x4000, 0x37b9: 0x4000, // Block 0xdf, offset 0x37c0 0x37c0: 0x0008, 0x37c1: 0x0008, 0x37c2: 0x0008, 0x37c3: 0x0001, 0x37c4: 0x0001, 0x37c5: 0x0001, 0x37c6: 0x0001, 0x37c7: 0x0001, 0x37c8: 0x0001, 0x37c9: 0x0001, 0x37ca: 0x0001, 0x37cb: 0x0001, 0x37cc: 0x0001, 0x37cd: 0x0001, 0x37ce: 0x0001, 0x37cf: 0x0001, 0x37d0: 0x0001, 0x37d1: 0x0001, 0x37d2: 0x0001, 0x37d3: 0x0001, 0x37d4: 0x0001, 0x37d5: 0x0001, 0x37d6: 0x0001, 0x37d7: 0x0001, 0x37d8: 0x0001, 0x37d9: 0x0001, 0x37da: 0x0001, 0x37db: 0x0001, 0x37dc: 0x0001, 0x37dd: 0x0001, 0x37de: 0x0001, 0x37df: 0x0001, 0x37e0: 0x0001, 0x37e1: 0x0001, 0x37e2: 0x0001, 0x37e3: 0x0001, 0x37e4: 0x0001, 0x37e5: 0x0001, 0x37e6: 0x0001, 0x37e7: 0x0008, 0x37e8: 0x0008, 0x37e9: 0x0008, 0x37ea: 0x0008, 0x37eb: 0x0008, 0x37ec: 0x0008, 0x37ed: 0x0008, 0x37ee: 0x0008, 0x37ef: 0x0008, 0x37f0: 0x0008, 0x37f1: 0x0008, 0x37f2: 0x0008, 0x37f3: 0x0008, 0x37f4: 0x0008, 0x37f6: 0x4000, 0x37f7: 0x4000, 0x37f8: 0x4000, 0x37f9: 0x4000, 0x37fa: 0x4000, 0x37fb: 0x4000, 0x37fc: 0x4000, 0x37fd: 0x4000, 0x37fe: 0x4000, 0x37ff: 0x4000, // Block 0xe0, offset 0x3800 0x3804: 0x0001, 0x3805: 0x0008, 0x3806: 0x0008, 0x3807: 0x0001, 0x3810: 0x0001, 0x3811: 0x0001, 0x3812: 0x0001, 0x3813: 0x0001, 0x3814: 0x0001, 0x3815: 0x0001, 0x3816: 0x0001, 0x3817: 0x0001, 0x3818: 0x0001, 0x3819: 0x0001, 0x381a: 0x0001, 0x381b: 0x0001, 0x381c: 0x0001, 0x381d: 0x0001, 0x381e: 0x0001, 0x381f: 0x0001, 0x3820: 0x0001, 0x3821: 0x0001, 0x3822: 0x0001, 0x3823: 0x0001, 0x3824: 0x0001, 0x3825: 0x0001, 0x3826: 0x0001, 0x3827: 0x0001, 0x3828: 0x0001, 0x3829: 0x0001, 0x382a: 0x0001, 0x382b: 0x0001, 0x382c: 0x0001, 0x382d: 0x0001, 0x382e: 0x0001, 0x382f: 0x0001, 0x3830: 0x0001, 0x3831: 0x0001, 0x3832: 0x0001, 0x3833: 0x0008, 0x3836: 0x0001, // Block 0xe1, offset 0x3840 0x3840: 0x0008, 0x3841: 0x0008, 0x3842: 0x0008, 0x3843: 0x0001, 0x3844: 0x0001, 0x3845: 0x0001, 0x3846: 0x0001, 0x3847: 0x0001, 0x3848: 0x0001, 0x3849: 0x0001, 0x384a: 0x0001, 0x384b: 0x0001, 0x384c: 0x0001, 0x384d: 0x0001, 0x384e: 0x0001, 0x384f: 0x0001, 0x3850: 0x0001, 0x3851: 0x0001, 0x3852: 0x0001, 0x3853: 0x0001, 0x3854: 0x0001, 0x3855: 0x0001, 0x3856: 0x0001, 0x3857: 0x0001, 0x3858: 0x0001, 0x3859: 0x0001, 0x385a: 0x0001, 0x385b: 0x0001, 0x385c: 0x0001, 0x385d: 0x0001, 0x385e: 0x0001, 0x385f: 0x0001, 0x3860: 0x0001, 0x3861: 0x0001, 0x3862: 0x0001, 0x3863: 0x0001, 0x3864: 0x0001, 0x3865: 0x0001, 0x3866: 0x0001, 0x3867: 0x0001, 0x3868: 0x0001, 0x3869: 0x0001, 0x386a: 0x0001, 0x386b: 0x0001, 0x386c: 0x0001, 0x386d: 0x0001, 0x386e: 0x0001, 0x386f: 0x0001, 0x3870: 0x0001, 0x3871: 0x0001, 0x3872: 0x0001, 0x3873: 0x0008, 0x3874: 0x0008, 0x3875: 0x0008, 0x3876: 0x0008, 0x3877: 0x0008, 0x3878: 0x0008, 0x3879: 0x0008, 0x387a: 0x0008, 0x387b: 0x0008, 0x387c: 0x0008, 0x387d: 0x0008, 0x387e: 0x0008, 0x387f: 0x0008, // Block 0xe2, offset 0x3880 0x3880: 0x0008, 0x3881: 0x0001, 0x3882: 0x0001, 0x3883: 0x0001, 0x3884: 0x0001, 0x3889: 0x0008, 0x388a: 0x0008, 0x388b: 0x0008, 0x388c: 0x0008, 0x388e: 0x0008, 0x388f: 0x0008, 0x3890: 0x4000, 0x3891: 0x4000, 0x3892: 0x4000, 0x3893: 0x4000, 0x3894: 0x4000, 0x3895: 0x4000, 0x3896: 0x4000, 0x3897: 0x4000, 0x3898: 0x4000, 0x3899: 0x4000, 0x389a: 0x0001, 0x389c: 0x0001, // Block 0xe3, offset 0x38c0 0x38c0: 0x0001, 0x38c1: 0x0001, 0x38c2: 0x0001, 0x38c3: 0x0001, 0x38c4: 0x0001, 0x38c5: 0x0001, 0x38c6: 0x0001, 0x38c7: 0x0001, 0x38c8: 0x0001, 0x38c9: 0x0001, 0x38ca: 0x0001, 0x38cb: 0x0001, 0x38cc: 0x0001, 0x38cd: 0x0001, 0x38ce: 0x0001, 0x38cf: 0x0001, 0x38d0: 0x0001, 0x38d1: 0x0001, 0x38d3: 0x0001, 0x38d4: 0x0001, 0x38d5: 0x0001, 0x38d6: 0x0001, 0x38d7: 0x0001, 0x38d8: 0x0001, 0x38d9: 0x0001, 0x38da: 0x0001, 0x38db: 0x0001, 0x38dc: 0x0001, 0x38dd: 0x0001, 0x38de: 0x0001, 0x38df: 0x0001, 0x38e0: 0x0001, 0x38e1: 0x0001, 0x38e2: 0x0001, 0x38e3: 0x0001, 0x38e4: 0x0001, 0x38e5: 0x0001, 0x38e6: 0x0001, 0x38e7: 0x0001, 0x38e8: 0x0001, 0x38e9: 0x0001, 0x38ea: 0x0001, 0x38eb: 0x0001, 0x38ec: 0x0008, 0x38ed: 0x0008, 0x38ee: 0x0008, 0x38ef: 0x0008, 0x38f0: 0x0008, 0x38f1: 0x0008, 0x38f2: 0x0008, 0x38f3: 0x0008, 0x38f4: 0x0008, 0x38f5: 0x0008, 0x38f6: 0x0008, 0x38f7: 0x0008, 0x38fe: 0x0008, 0x38ff: 0x0001, // Block 0xe4, offset 0x3900 0x3900: 0x0001, 0x3901: 0x0008, // Block 0xe5, offset 0x3940 0x3940: 0x0001, 0x3941: 0x0001, 0x3942: 0x0001, 0x3943: 0x0001, 0x3944: 0x0001, 0x3945: 0x0001, 0x3946: 0x0001, 0x3948: 0x0001, 0x394a: 0x0001, 0x394b: 0x0001, 0x394c: 0x0001, 0x394d: 0x0001, 0x394f: 0x0001, 0x3950: 0x0001, 0x3951: 0x0001, 0x3952: 0x0001, 0x3953: 0x0001, 0x3954: 0x0001, 0x3955: 0x0001, 0x3956: 0x0001, 0x3957: 0x0001, 0x3958: 0x0001, 0x3959: 0x0001, 0x395a: 0x0001, 0x395b: 0x0001, 0x395c: 0x0001, 0x395d: 0x0001, 0x395f: 0x0001, 0x3960: 0x0001, 0x3961: 0x0001, 0x3962: 0x0001, 0x3963: 0x0001, 0x3964: 0x0001, 0x3965: 0x0001, 0x3966: 0x0001, 0x3967: 0x0001, 0x3968: 0x0001, 0x3970: 0x0001, 0x3971: 0x0001, 0x3972: 0x0001, 0x3973: 0x0001, 0x3974: 0x0001, 0x3975: 0x0001, 0x3976: 0x0001, 0x3977: 0x0001, 0x3978: 0x0001, 0x3979: 0x0001, 0x397a: 0x0001, 0x397b: 0x0001, 0x397c: 0x0001, 0x397d: 0x0001, 0x397e: 0x0001, 0x397f: 0x0001, // Block 0xe6, offset 0x3980 0x3980: 0x0001, 0x3981: 0x0001, 0x3982: 0x0001, 0x3983: 0x0001, 0x3984: 0x0001, 0x3985: 0x0001, 0x3986: 0x0001, 0x3987: 0x0001, 0x3988: 0x0001, 0x3989: 0x0001, 0x398a: 0x0001, 0x398b: 0x0001, 0x398c: 0x0001, 0x398d: 0x0001, 0x398e: 0x0001, 0x398f: 0x0001, 0x3990: 0x0001, 0x3991: 0x0001, 0x3992: 0x0001, 0x3993: 0x0001, 0x3994: 0x0001, 0x3995: 0x0001, 0x3996: 0x0001, 0x3997: 0x0001, 0x3998: 0x0001, 0x3999: 0x0001, 0x399a: 0x0001, 0x399b: 0x0001, 0x399c: 0x0001, 0x399d: 0x0001, 0x399e: 0x0001, 0x399f: 0x0008, 0x39a0: 0x0008, 0x39a1: 0x0008, 0x39a2: 0x0008, 0x39a3: 0x0008, 0x39a4: 0x0008, 0x39a5: 0x0008, 0x39a6: 0x0008, 0x39a7: 0x0008, 0x39a8: 0x0008, 0x39a9: 0x0008, 0x39aa: 0x0008, 0x39b0: 0x4000, 0x39b1: 0x4000, 0x39b2: 0x4000, 0x39b3: 0x4000, 0x39b4: 0x4000, 0x39b5: 0x4000, 0x39b6: 0x4000, 0x39b7: 0x4000, 0x39b8: 0x4000, 0x39b9: 0x4000, // Block 0xe7, offset 0x39c0 0x39c0: 0x0008, 0x39c1: 0x0008, 0x39c2: 0x0008, 0x39c3: 0x0008, 0x39c5: 0x0001, 0x39c6: 0x0001, 0x39c7: 0x0001, 0x39c8: 0x0001, 0x39c9: 0x0001, 0x39ca: 0x0001, 0x39cb: 0x0001, 0x39cc: 0x0001, 0x39cf: 0x0001, 0x39d0: 0x0001, 0x39d3: 0x0001, 0x39d4: 0x0001, 0x39d5: 0x0001, 0x39d6: 0x0001, 0x39d7: 0x0001, 0x39d8: 0x0001, 0x39d9: 0x0001, 0x39da: 0x0001, 0x39db: 0x0001, 0x39dc: 0x0001, 0x39dd: 0x0001, 0x39de: 0x0001, 0x39df: 0x0001, 0x39e0: 0x0001, 0x39e1: 0x0001, 0x39e2: 0x0001, 0x39e3: 0x0001, 0x39e4: 0x0001, 0x39e5: 0x0001, 0x39e6: 0x0001, 0x39e7: 0x0001, 0x39e8: 0x0001, 0x39ea: 0x0001, 0x39eb: 0x0001, 0x39ec: 0x0001, 0x39ed: 0x0001, 0x39ee: 0x0001, 0x39ef: 0x0001, 0x39f0: 0x0001, 0x39f2: 0x0001, 0x39f3: 0x0001, 0x39f5: 0x0001, 0x39f6: 0x0001, 0x39f7: 0x0001, 0x39f8: 0x0001, 0x39f9: 0x0001, 0x39fb: 0x0008, 0x39fc: 0x0008, 0x39fd: 0x0001, 0x39fe: 0x0008, 0x39ff: 0x0008, // Block 0xe8, offset 0x3a00 0x3a00: 0x0008, 0x3a01: 0x0008, 0x3a02: 0x0008, 0x3a03: 0x0008, 0x3a04: 0x0008, 0x3a07: 0x0008, 0x3a08: 0x0008, 0x3a0b: 0x0008, 0x3a0c: 0x0008, 0x3a0d: 0x0008, 0x3a10: 0x0001, 0x3a17: 0x0008, 0x3a1d: 0x0001, 0x3a1e: 0x0001, 0x3a1f: 0x0001, 0x3a20: 0x0001, 0x3a21: 0x0001, 0x3a22: 0x0008, 0x3a23: 0x0008, 0x3a26: 0x0008, 0x3a27: 0x0008, 0x3a28: 0x0008, 0x3a29: 0x0008, 0x3a2a: 0x0008, 0x3a2b: 0x0008, 0x3a2c: 0x0008, 0x3a30: 0x0008, 0x3a31: 0x0008, 0x3a32: 0x0008, 0x3a33: 0x0008, 0x3a34: 0x0008, // Block 0xe9, offset 0x3a40 0x3a40: 0x0001, 0x3a41: 0x0001, 0x3a42: 0x0001, 0x3a43: 0x0001, 0x3a44: 0x0001, 0x3a45: 0x0001, 0x3a46: 0x0001, 0x3a47: 0x0001, 0x3a48: 0x0001, 0x3a49: 0x0001, 0x3a4b: 0x0001, 0x3a4e: 0x0001, 0x3a50: 0x0001, 0x3a51: 0x0001, 0x3a52: 0x0001, 0x3a53: 0x0001, 0x3a54: 0x0001, 0x3a55: 0x0001, 0x3a56: 0x0001, 0x3a57: 0x0001, 0x3a58: 0x0001, 0x3a59: 0x0001, 0x3a5a: 0x0001, 0x3a5b: 0x0001, 0x3a5c: 0x0001, 0x3a5d: 0x0001, 0x3a5e: 0x0001, 0x3a5f: 0x0001, 0x3a60: 0x0001, 0x3a61: 0x0001, 0x3a62: 0x0001, 0x3a63: 0x0001, 0x3a64: 0x0001, 0x3a65: 0x0001, 0x3a66: 0x0001, 0x3a67: 0x0001, 0x3a68: 0x0001, 0x3a69: 0x0001, 0x3a6a: 0x0001, 0x3a6b: 0x0001, 0x3a6c: 0x0001, 0x3a6d: 0x0001, 0x3a6e: 0x0001, 0x3a6f: 0x0001, 0x3a70: 0x0001, 0x3a71: 0x0001, 0x3a72: 0x0001, 0x3a73: 0x0001, 0x3a74: 0x0001, 0x3a75: 0x0001, 0x3a77: 0x0001, 0x3a78: 0x0008, 0x3a79: 0x0008, 0x3a7a: 0x0008, 0x3a7b: 0x0008, 0x3a7c: 0x0008, 0x3a7d: 0x0008, 0x3a7e: 0x0008, 0x3a7f: 0x0008, // Block 0xea, offset 0x3a80 0x3a80: 0x0008, 0x3a82: 0x0008, 0x3a85: 0x0008, 0x3a87: 0x0008, 0x3a88: 0x0008, 0x3a89: 0x0008, 0x3a8a: 0x0008, 0x3a8c: 0x0008, 0x3a8d: 0x0008, 0x3a8e: 0x0008, 0x3a8f: 0x0008, 0x3a90: 0x0008, 0x3a91: 0x0001, 0x3a92: 0x0008, 0x3a93: 0x0001, 0x3aa1: 0x0008, 0x3aa2: 0x0008, // Block 0xeb, offset 0x3ac0 0x3ac0: 0x0001, 0x3ac1: 0x0001, 0x3ac2: 0x0001, 0x3ac3: 0x0001, 0x3ac4: 0x0001, 0x3ac5: 0x0001, 0x3ac6: 0x0001, 0x3ac7: 0x0001, 0x3ac8: 0x0001, 0x3ac9: 0x0001, 0x3aca: 0x0001, 0x3acb: 0x0001, 0x3acc: 0x0001, 0x3acd: 0x0001, 0x3ace: 0x0001, 0x3acf: 0x0001, 0x3ad0: 0x0001, 0x3ad1: 0x0001, 0x3ad2: 0x0001, 0x3ad3: 0x0001, 0x3ad4: 0x0001, 0x3ad5: 0x0001, 0x3ad6: 0x0001, 0x3ad7: 0x0001, 0x3ad8: 0x0001, 0x3ad9: 0x0001, 0x3ada: 0x0001, 0x3adb: 0x0001, 0x3adc: 0x0001, 0x3add: 0x0001, 0x3ade: 0x0001, 0x3adf: 0x0001, 0x3ae0: 0x0001, 0x3ae1: 0x0001, 0x3ae2: 0x0001, 0x3ae3: 0x0001, 0x3ae4: 0x0001, 0x3ae5: 0x0001, 0x3ae6: 0x0001, 0x3ae7: 0x0001, 0x3ae8: 0x0001, 0x3ae9: 0x0001, 0x3aea: 0x0001, 0x3aeb: 0x0001, 0x3aec: 0x0001, 0x3aed: 0x0001, 0x3aee: 0x0001, 0x3aef: 0x0001, 0x3af0: 0x0001, 0x3af1: 0x0001, 0x3af2: 0x0001, 0x3af3: 0x0001, 0x3af4: 0x0001, 0x3af5: 0x0008, 0x3af6: 0x0008, 0x3af7: 0x0008, 0x3af8: 0x0008, 0x3af9: 0x0008, 0x3afa: 0x0008, 0x3afb: 0x0008, 0x3afc: 0x0008, 0x3afd: 0x0008, 0x3afe: 0x0008, 0x3aff: 0x0008, // Block 0xec, offset 0x3b00 0x3b00: 0x0008, 0x3b01: 0x0008, 0x3b02: 0x0008, 0x3b03: 0x0008, 0x3b04: 0x0008, 0x3b05: 0x0008, 0x3b06: 0x0008, 0x3b07: 0x0001, 0x3b08: 0x0001, 0x3b09: 0x0001, 0x3b0a: 0x0001, 0x3b10: 0x4000, 0x3b11: 0x4000, 0x3b12: 0x4000, 0x3b13: 0x4000, 0x3b14: 0x4000, 0x3b15: 0x4000, 0x3b16: 0x4000, 0x3b17: 0x4000, 0x3b18: 0x4000, 0x3b19: 0x4000, 0x3b1e: 0x0008, 0x3b1f: 0x0001, 0x3b20: 0x0001, 0x3b21: 0x0001, // Block 0xed, offset 0x3b40 0x3b40: 0x0001, 0x3b41: 0x0001, 0x3b42: 0x0001, 0x3b43: 0x0001, 0x3b44: 0x0001, 0x3b45: 0x0001, 0x3b46: 0x0001, 0x3b47: 0x0001, 0x3b48: 0x0001, 0x3b49: 0x0001, 0x3b4a: 0x0001, 0x3b4b: 0x0001, 0x3b4c: 0x0001, 0x3b4d: 0x0001, 0x3b4e: 0x0001, 0x3b4f: 0x0001, 0x3b50: 0x0001, 0x3b51: 0x0001, 0x3b52: 0x0001, 0x3b53: 0x0001, 0x3b54: 0x0001, 0x3b55: 0x0001, 0x3b56: 0x0001, 0x3b57: 0x0001, 0x3b58: 0x0001, 0x3b59: 0x0001, 0x3b5a: 0x0001, 0x3b5b: 0x0001, 0x3b5c: 0x0001, 0x3b5d: 0x0001, 0x3b5e: 0x0001, 0x3b5f: 0x0001, 0x3b60: 0x0001, 0x3b61: 0x0001, 0x3b62: 0x0001, 0x3b63: 0x0001, 0x3b64: 0x0001, 0x3b65: 0x0001, 0x3b66: 0x0001, 0x3b67: 0x0001, 0x3b68: 0x0001, 0x3b69: 0x0001, 0x3b6a: 0x0001, 0x3b6b: 0x0001, 0x3b6c: 0x0001, 0x3b6d: 0x0001, 0x3b6e: 0x0001, 0x3b6f: 0x0001, 0x3b70: 0x0008, 0x3b71: 0x0008, 0x3b72: 0x0008, 0x3b73: 0x0008, 0x3b74: 0x0008, 0x3b75: 0x0008, 0x3b76: 0x0008, 0x3b77: 0x0008, 0x3b78: 0x0008, 0x3b79: 0x0008, 0x3b7a: 0x0008, 0x3b7b: 0x0008, 0x3b7c: 0x0008, 0x3b7d: 0x0008, 0x3b7e: 0x0008, 0x3b7f: 0x0008, // Block 0xee, offset 0x3b80 0x3b80: 0x0008, 0x3b81: 0x0008, 0x3b82: 0x0008, 0x3b83: 0x0008, 0x3b84: 0x0001, 0x3b85: 0x0001, 0x3b87: 0x0001, 0x3b90: 0x4000, 0x3b91: 0x4000, 0x3b92: 0x4000, 0x3b93: 0x4000, 0x3b94: 0x4000, 0x3b95: 0x4000, 0x3b96: 0x4000, 0x3b97: 0x4000, 0x3b98: 0x4000, 0x3b99: 0x4000, // Block 0xef, offset 0x3bc0 0x3bc0: 0x0001, 0x3bc1: 0x0001, 0x3bc2: 0x0001, 0x3bc3: 0x0001, 0x3bc4: 0x0001, 0x3bc5: 0x0001, 0x3bc6: 0x0001, 0x3bc7: 0x0001, 0x3bc8: 0x0001, 0x3bc9: 0x0001, 0x3bca: 0x0001, 0x3bcb: 0x0001, 0x3bcc: 0x0001, 0x3bcd: 0x0001, 0x3bce: 0x0001, 0x3bcf: 0x0001, 0x3bd0: 0x0001, 0x3bd1: 0x0001, 0x3bd2: 0x0001, 0x3bd3: 0x0001, 0x3bd4: 0x0001, 0x3bd5: 0x0001, 0x3bd6: 0x0001, 0x3bd7: 0x0001, 0x3bd8: 0x0001, 0x3bd9: 0x0001, 0x3bda: 0x0001, 0x3bdb: 0x0001, 0x3bdc: 0x0001, 0x3bdd: 0x0001, 0x3bde: 0x0001, 0x3bdf: 0x0001, 0x3be0: 0x0001, 0x3be1: 0x0001, 0x3be2: 0x0001, 0x3be3: 0x0001, 0x3be4: 0x0001, 0x3be5: 0x0001, 0x3be6: 0x0001, 0x3be7: 0x0001, 0x3be8: 0x0001, 0x3be9: 0x0001, 0x3bea: 0x0001, 0x3beb: 0x0001, 0x3bec: 0x0001, 0x3bed: 0x0001, 0x3bee: 0x0001, 0x3bef: 0x0008, 0x3bf0: 0x0008, 0x3bf1: 0x0008, 0x3bf2: 0x0008, 0x3bf3: 0x0008, 0x3bf4: 0x0008, 0x3bf5: 0x0008, 0x3bf8: 0x0008, 0x3bf9: 0x0008, 0x3bfa: 0x0008, 0x3bfb: 0x0008, 0x3bfc: 0x0008, 0x3bfd: 0x0008, 0x3bfe: 0x0008, 0x3bff: 0x0008, // Block 0xf0, offset 0x3c00 0x3c00: 0x0008, 0x3c18: 0x0001, 0x3c19: 0x0001, 0x3c1a: 0x0001, 0x3c1b: 0x0001, 0x3c1c: 0x0008, 0x3c1d: 0x0008, // Block 0xf1, offset 0x3c40 0x3c40: 0x0008, 0x3c44: 0x0001, 0x3c50: 0x4000, 0x3c51: 0x4000, 0x3c52: 0x4000, 0x3c53: 0x4000, 0x3c54: 0x4000, 0x3c55: 0x4000, 0x3c56: 0x4000, 0x3c57: 0x4000, 0x3c58: 0x4000, 0x3c59: 0x4000, // Block 0xf2, offset 0x3c80 0x3c80: 0x0001, 0x3c81: 0x0001, 0x3c82: 0x0001, 0x3c83: 0x0001, 0x3c84: 0x0001, 0x3c85: 0x0001, 0x3c86: 0x0001, 0x3c87: 0x0001, 0x3c88: 0x0001, 0x3c89: 0x0001, 0x3c8a: 0x0001, 0x3c8b: 0x0001, 0x3c8c: 0x0001, 0x3c8d: 0x0001, 0x3c8e: 0x0001, 0x3c8f: 0x0001, 0x3c90: 0x0001, 0x3c91: 0x0001, 0x3c92: 0x0001, 0x3c93: 0x0001, 0x3c94: 0x0001, 0x3c95: 0x0001, 0x3c96: 0x0001, 0x3c97: 0x0001, 0x3c98: 0x0001, 0x3c99: 0x0001, 0x3c9a: 0x0001, 0x3c9b: 0x0001, 0x3c9c: 0x0001, 0x3c9d: 0x0001, 0x3c9e: 0x0001, 0x3c9f: 0x0001, 0x3ca0: 0x0001, 0x3ca1: 0x0001, 0x3ca2: 0x0001, 0x3ca3: 0x0001, 0x3ca4: 0x0001, 0x3ca5: 0x0001, 0x3ca6: 0x0001, 0x3ca7: 0x0001, 0x3ca8: 0x0001, 0x3ca9: 0x0001, 0x3caa: 0x0001, 0x3cab: 0x0008, 0x3cac: 0x0008, 0x3cad: 0x0008, 0x3cae: 0x0008, 0x3caf: 0x0008, 0x3cb0: 0x0008, 0x3cb1: 0x0008, 0x3cb2: 0x0008, 0x3cb3: 0x0008, 0x3cb4: 0x0008, 0x3cb5: 0x0008, 0x3cb6: 0x0008, 0x3cb7: 0x0008, 0x3cb8: 0x0001, // Block 0xf3, offset 0x3cc0 0x3cc0: 0x4000, 0x3cc1: 0x4000, 0x3cc2: 0x4000, 0x3cc3: 0x4000, 0x3cc4: 0x4000, 0x3cc5: 0x4000, 0x3cc6: 0x4000, 0x3cc7: 0x4000, 0x3cc8: 0x4000, 0x3cc9: 0x4000, 0x3cd0: 0x4000, 0x3cd1: 0x4000, 0x3cd2: 0x4000, 0x3cd3: 0x4000, 0x3cd4: 0x4000, 0x3cd5: 0x4000, 0x3cd6: 0x4000, 0x3cd7: 0x4000, 0x3cd8: 0x4000, 0x3cd9: 0x4000, 0x3cda: 0x4000, 0x3cdb: 0x4000, 0x3cdc: 0x4000, 0x3cdd: 0x4000, 0x3cde: 0x4000, 0x3cdf: 0x4000, 0x3ce0: 0x4000, 0x3ce1: 0x4000, 0x3ce2: 0x4000, 0x3ce3: 0x4000, // Block 0xf4, offset 0x3d00 0x3d1d: 0x0008, 0x3d1e: 0x0008, 0x3d1f: 0x0008, 0x3d20: 0x0008, 0x3d21: 0x0008, 0x3d22: 0x0008, 0x3d23: 0x0008, 0x3d24: 0x0008, 0x3d25: 0x0008, 0x3d26: 0x0008, 0x3d27: 0x0008, 0x3d28: 0x0008, 0x3d29: 0x0008, 0x3d2a: 0x0008, 0x3d2b: 0x0008, 0x3d30: 0x4000, 0x3d31: 0x4000, 0x3d32: 0x4000, 0x3d33: 0x4000, 0x3d34: 0x4000, 0x3d35: 0x4000, 0x3d36: 0x4000, 0x3d37: 0x4000, 0x3d38: 0x4000, 0x3d39: 0x4000, // Block 0xf5, offset 0x3d40 0x3d40: 0x0001, 0x3d41: 0x0001, 0x3d42: 0x0001, 0x3d43: 0x0001, 0x3d44: 0x0001, 0x3d45: 0x0001, 0x3d46: 0x0001, 0x3d47: 0x0001, 0x3d48: 0x0001, 0x3d49: 0x0001, 0x3d4a: 0x0001, 0x3d4b: 0x0001, 0x3d4c: 0x0001, 0x3d4d: 0x0001, 0x3d4e: 0x0001, 0x3d4f: 0x0001, 0x3d50: 0x0001, 0x3d51: 0x0001, 0x3d52: 0x0001, 0x3d53: 0x0001, 0x3d54: 0x0001, 0x3d55: 0x0001, 0x3d56: 0x0001, 0x3d57: 0x0001, 0x3d58: 0x0001, 0x3d59: 0x0001, 0x3d5a: 0x0001, 0x3d5b: 0x0001, 0x3d5c: 0x0001, 0x3d5d: 0x0001, 0x3d5e: 0x0001, 0x3d5f: 0x0001, 0x3d60: 0x0001, 0x3d61: 0x0001, 0x3d62: 0x0001, 0x3d63: 0x0001, 0x3d64: 0x0001, 0x3d65: 0x0001, 0x3d66: 0x0001, 0x3d67: 0x0001, 0x3d68: 0x0001, 0x3d69: 0x0001, 0x3d6a: 0x0001, 0x3d6b: 0x0001, 0x3d6c: 0x0008, 0x3d6d: 0x0008, 0x3d6e: 0x0008, 0x3d6f: 0x0008, 0x3d70: 0x0008, 0x3d71: 0x0008, 0x3d72: 0x0008, 0x3d73: 0x0008, 0x3d74: 0x0008, 0x3d75: 0x0008, 0x3d76: 0x0008, 0x3d77: 0x0008, 0x3d78: 0x0008, 0x3d79: 0x0008, 0x3d7a: 0x0008, // Block 0xf6, offset 0x3d80 0x3da0: 0x0001, 0x3da1: 0x0001, 0x3da2: 0x0001, 0x3da3: 0x0001, 0x3da4: 0x0001, 0x3da5: 0x0001, 0x3da6: 0x0001, 0x3da7: 0x0001, 0x3da8: 0x0001, 0x3da9: 0x0001, 0x3daa: 0x0001, 0x3dab: 0x0001, 0x3dac: 0x0001, 0x3dad: 0x0001, 0x3dae: 0x0001, 0x3daf: 0x0001, 0x3db0: 0x0001, 0x3db1: 0x0001, 0x3db2: 0x0001, 0x3db3: 0x0001, 0x3db4: 0x0001, 0x3db5: 0x0001, 0x3db6: 0x0001, 0x3db7: 0x0001, 0x3db8: 0x0001, 0x3db9: 0x0001, 0x3dba: 0x0001, 0x3dbb: 0x0001, 0x3dbc: 0x0001, 0x3dbd: 0x0001, 0x3dbe: 0x0001, 0x3dbf: 0x0001, // Block 0xf7, offset 0x3dc0 0x3dc0: 0x0001, 0x3dc1: 0x0001, 0x3dc2: 0x0001, 0x3dc3: 0x0001, 0x3dc4: 0x0001, 0x3dc5: 0x0001, 0x3dc6: 0x0001, 0x3dc7: 0x0001, 0x3dc8: 0x0001, 0x3dc9: 0x0001, 0x3dca: 0x0001, 0x3dcb: 0x0001, 0x3dcc: 0x0001, 0x3dcd: 0x0001, 0x3dce: 0x0001, 0x3dcf: 0x0001, 0x3dd0: 0x0001, 0x3dd1: 0x0001, 0x3dd2: 0x0001, 0x3dd3: 0x0001, 0x3dd4: 0x0001, 0x3dd5: 0x0001, 0x3dd6: 0x0001, 0x3dd7: 0x0001, 0x3dd8: 0x0001, 0x3dd9: 0x0001, 0x3dda: 0x0001, 0x3ddb: 0x0001, 0x3ddc: 0x0001, 0x3ddd: 0x0001, 0x3dde: 0x0001, 0x3ddf: 0x0001, 0x3de0: 0x4000, 0x3de1: 0x4000, 0x3de2: 0x4000, 0x3de3: 0x4000, 0x3de4: 0x4000, 0x3de5: 0x4000, 0x3de6: 0x4000, 0x3de7: 0x4000, 0x3de8: 0x4000, 0x3de9: 0x4000, 0x3dff: 0x0001, // Block 0xf8, offset 0x3e00 0x3e00: 0x0001, 0x3e01: 0x0001, 0x3e02: 0x0001, 0x3e03: 0x0001, 0x3e04: 0x0001, 0x3e05: 0x0001, 0x3e06: 0x0001, 0x3e09: 0x0001, 0x3e0c: 0x0001, 0x3e0d: 0x0001, 0x3e0e: 0x0001, 0x3e0f: 0x0001, 0x3e10: 0x0001, 0x3e11: 0x0001, 0x3e12: 0x0001, 0x3e13: 0x0001, 0x3e15: 0x0001, 0x3e16: 0x0001, 0x3e18: 0x0001, 0x3e19: 0x0001, 0x3e1a: 0x0001, 0x3e1b: 0x0001, 0x3e1c: 0x0001, 0x3e1d: 0x0001, 0x3e1e: 0x0001, 0x3e1f: 0x0001, 0x3e20: 0x0001, 0x3e21: 0x0001, 0x3e22: 0x0001, 0x3e23: 0x0001, 0x3e24: 0x0001, 0x3e25: 0x0001, 0x3e26: 0x0001, 0x3e27: 0x0001, 0x3e28: 0x0001, 0x3e29: 0x0001, 0x3e2a: 0x0001, 0x3e2b: 0x0001, 0x3e2c: 0x0001, 0x3e2d: 0x0001, 0x3e2e: 0x0001, 0x3e2f: 0x0001, 0x3e30: 0x0008, 0x3e31: 0x0008, 0x3e32: 0x0008, 0x3e33: 0x0008, 0x3e34: 0x0008, 0x3e35: 0x0008, 0x3e37: 0x0008, 0x3e38: 0x0008, 0x3e3b: 0x0008, 0x3e3c: 0x0008, 0x3e3d: 0x0008, 0x3e3e: 0x0008, 0x3e3f: 0x0001, // Block 0xf9, offset 0x3e40 0x3e40: 0x0008, 0x3e41: 0x0001, 0x3e42: 0x0008, 0x3e43: 0x0008, 0x3e50: 0x4000, 0x3e51: 0x4000, 0x3e52: 0x4000, 0x3e53: 0x4000, 0x3e54: 0x4000, 0x3e55: 0x4000, 0x3e56: 0x4000, 0x3e57: 0x4000, 0x3e58: 0x4000, 0x3e59: 0x4000, // Block 0xfa, offset 0x3e80 0x3ea0: 0x0001, 0x3ea1: 0x0001, 0x3ea2: 0x0001, 0x3ea3: 0x0001, 0x3ea4: 0x0001, 0x3ea5: 0x0001, 0x3ea6: 0x0001, 0x3ea7: 0x0001, 0x3eaa: 0x0001, 0x3eab: 0x0001, 0x3eac: 0x0001, 0x3ead: 0x0001, 0x3eae: 0x0001, 0x3eaf: 0x0001, 0x3eb0: 0x0001, 0x3eb1: 0x0001, 0x3eb2: 0x0001, 0x3eb3: 0x0001, 0x3eb4: 0x0001, 0x3eb5: 0x0001, 0x3eb6: 0x0001, 0x3eb7: 0x0001, 0x3eb8: 0x0001, 0x3eb9: 0x0001, 0x3eba: 0x0001, 0x3ebb: 0x0001, 0x3ebc: 0x0001, 0x3ebd: 0x0001, 0x3ebe: 0x0001, 0x3ebf: 0x0001, // Block 0xfb, offset 0x3ec0 0x3ec0: 0x0001, 0x3ec1: 0x0001, 0x3ec2: 0x0001, 0x3ec3: 0x0001, 0x3ec4: 0x0001, 0x3ec5: 0x0001, 0x3ec6: 0x0001, 0x3ec7: 0x0001, 0x3ec8: 0x0001, 0x3ec9: 0x0001, 0x3eca: 0x0001, 0x3ecb: 0x0001, 0x3ecc: 0x0001, 0x3ecd: 0x0001, 0x3ece: 0x0001, 0x3ecf: 0x0001, 0x3ed0: 0x0001, 0x3ed1: 0x0008, 0x3ed2: 0x0008, 0x3ed3: 0x0008, 0x3ed4: 0x0008, 0x3ed5: 0x0008, 0x3ed6: 0x0008, 0x3ed7: 0x0008, 0x3eda: 0x0008, 0x3edb: 0x0008, 0x3edc: 0x0008, 0x3edd: 0x0008, 0x3ede: 0x0008, 0x3edf: 0x0008, 0x3ee0: 0x0008, 0x3ee1: 0x0001, 0x3ee3: 0x0001, 0x3ee4: 0x0008, // Block 0xfc, offset 0x3f00 0x3f00: 0x0001, 0x3f01: 0x0008, 0x3f02: 0x0008, 0x3f03: 0x0008, 0x3f04: 0x0008, 0x3f05: 0x0008, 0x3f06: 0x0008, 0x3f07: 0x0008, 0x3f08: 0x0008, 0x3f09: 0x0008, 0x3f0a: 0x0008, 0x3f0b: 0x0001, 0x3f0c: 0x0001, 0x3f0d: 0x0001, 0x3f0e: 0x0001, 0x3f0f: 0x0001, 0x3f10: 0x0001, 0x3f11: 0x0001, 0x3f12: 0x0001, 0x3f13: 0x0001, 0x3f14: 0x0001, 0x3f15: 0x0001, 0x3f16: 0x0001, 0x3f17: 0x0001, 0x3f18: 0x0001, 0x3f19: 0x0001, 0x3f1a: 0x0001, 0x3f1b: 0x0001, 0x3f1c: 0x0001, 0x3f1d: 0x0001, 0x3f1e: 0x0001, 0x3f1f: 0x0001, 0x3f20: 0x0001, 0x3f21: 0x0001, 0x3f22: 0x0001, 0x3f23: 0x0001, 0x3f24: 0x0001, 0x3f25: 0x0001, 0x3f26: 0x0001, 0x3f27: 0x0001, 0x3f28: 0x0001, 0x3f29: 0x0001, 0x3f2a: 0x0001, 0x3f2b: 0x0001, 0x3f2c: 0x0001, 0x3f2d: 0x0001, 0x3f2e: 0x0001, 0x3f2f: 0x0001, 0x3f30: 0x0001, 0x3f31: 0x0001, 0x3f32: 0x0001, 0x3f33: 0x0008, 0x3f34: 0x0008, 0x3f35: 0x0008, 0x3f36: 0x0008, 0x3f37: 0x0008, 0x3f38: 0x0008, 0x3f39: 0x0008, 0x3f3a: 0x0001, 0x3f3b: 0x0008, 0x3f3c: 0x0008, 0x3f3d: 0x0008, 0x3f3e: 0x0008, // Block 0xfd, offset 0x3f40 0x3f47: 0x0008, 0x3f50: 0x0001, 0x3f51: 0x0008, 0x3f52: 0x0008, 0x3f53: 0x0008, 0x3f54: 0x0008, 0x3f55: 0x0008, 0x3f56: 0x0008, 0x3f57: 0x0008, 0x3f58: 0x0008, 0x3f59: 0x0008, 0x3f5a: 0x0008, 0x3f5b: 0x0008, 0x3f5c: 0x0001, 0x3f5d: 0x0001, 0x3f5e: 0x0001, 0x3f5f: 0x0001, 0x3f60: 0x0001, 0x3f61: 0x0001, 0x3f62: 0x0001, 0x3f63: 0x0001, 0x3f64: 0x0001, 0x3f65: 0x0001, 0x3f66: 0x0001, 0x3f67: 0x0001, 0x3f68: 0x0001, 0x3f69: 0x0001, 0x3f6a: 0x0001, 0x3f6b: 0x0001, 0x3f6c: 0x0001, 0x3f6d: 0x0001, 0x3f6e: 0x0001, 0x3f6f: 0x0001, 0x3f70: 0x0001, 0x3f71: 0x0001, 0x3f72: 0x0001, 0x3f73: 0x0001, 0x3f74: 0x0001, 0x3f75: 0x0001, 0x3f76: 0x0001, 0x3f77: 0x0001, 0x3f78: 0x0001, 0x3f79: 0x0001, 0x3f7a: 0x0001, 0x3f7b: 0x0001, 0x3f7c: 0x0001, 0x3f7d: 0x0001, 0x3f7e: 0x0001, 0x3f7f: 0x0001, // Block 0xfe, offset 0x3f80 0x3f80: 0x0001, 0x3f81: 0x0001, 0x3f82: 0x0001, 0x3f83: 0x0001, 0x3f84: 0x0001, 0x3f85: 0x0001, 0x3f86: 0x0001, 0x3f87: 0x0001, 0x3f88: 0x0001, 0x3f89: 0x0001, 0x3f8a: 0x0008, 0x3f8b: 0x0008, 0x3f8c: 0x0008, 0x3f8d: 0x0008, 0x3f8e: 0x0008, 0x3f8f: 0x0008, 0x3f90: 0x0008, 0x3f91: 0x0008, 0x3f92: 0x0008, 0x3f93: 0x0008, 0x3f94: 0x0008, 0x3f95: 0x0008, 0x3f96: 0x0008, 0x3f97: 0x0008, 0x3f98: 0x0008, 0x3f99: 0x0008, 0x3f9d: 0x0001, 0x3fb0: 0x0001, 0x3fb1: 0x0001, 0x3fb2: 0x0001, 0x3fb3: 0x0001, 0x3fb4: 0x0001, 0x3fb5: 0x0001, 0x3fb6: 0x0001, 0x3fb7: 0x0001, 0x3fb8: 0x0001, 0x3fb9: 0x0001, 0x3fba: 0x0001, 0x3fbb: 0x0001, 0x3fbc: 0x0001, 0x3fbd: 0x0001, 0x3fbe: 0x0001, 0x3fbf: 0x0001, // Block 0xff, offset 0x3fc0 0x3fe0: 0x0008, 0x3fe1: 0x0008, 0x3fe2: 0x0008, 0x3fe3: 0x0008, 0x3fe4: 0x0008, 0x3fe5: 0x0008, 0x3fe6: 0x0008, 0x3fe7: 0x0008, // Block 0x100, offset 0x4000 0x4000: 0x0001, 0x4001: 0x0001, 0x4002: 0x0001, 0x4003: 0x0001, 0x4004: 0x0001, 0x4005: 0x0001, 0x4006: 0x0001, 0x4007: 0x0001, 0x4008: 0x0001, 0x4009: 0x0001, 0x400a: 0x0001, 0x400b: 0x0001, 0x400c: 0x0001, 0x400d: 0x0001, 0x400e: 0x0001, 0x400f: 0x0001, 0x4010: 0x0001, 0x4011: 0x0001, 0x4012: 0x0001, 0x4013: 0x0001, 0x4014: 0x0001, 0x4015: 0x0001, 0x4016: 0x0001, 0x4017: 0x0001, 0x4018: 0x0001, 0x4019: 0x0001, 0x401a: 0x0001, 0x401b: 0x0001, 0x401c: 0x0001, 0x401d: 0x0001, 0x401e: 0x0001, 0x401f: 0x0001, 0x4020: 0x0001, 0x4030: 0x4000, 0x4031: 0x4000, 0x4032: 0x4000, 0x4033: 0x4000, 0x4034: 0x4000, 0x4035: 0x4000, 0x4036: 0x4000, 0x4037: 0x4000, 0x4038: 0x4000, 0x4039: 0x4000, // Block 0x101, offset 0x4040 0x4040: 0x0001, 0x4041: 0x0001, 0x4042: 0x0001, 0x4043: 0x0001, 0x4044: 0x0001, 0x4045: 0x0001, 0x4046: 0x0001, 0x4047: 0x0001, 0x4048: 0x0001, 0x404a: 0x0001, 0x404b: 0x0001, 0x404c: 0x0001, 0x404d: 0x0001, 0x404e: 0x0001, 0x404f: 0x0001, 0x4050: 0x0001, 0x4051: 0x0001, 0x4052: 0x0001, 0x4053: 0x0001, 0x4054: 0x0001, 0x4055: 0x0001, 0x4056: 0x0001, 0x4057: 0x0001, 0x4058: 0x0001, 0x4059: 0x0001, 0x405a: 0x0001, 0x405b: 0x0001, 0x405c: 0x0001, 0x405d: 0x0001, 0x405e: 0x0001, 0x405f: 0x0001, 0x4060: 0x0001, 0x4061: 0x0001, 0x4062: 0x0001, 0x4063: 0x0001, 0x4064: 0x0001, 0x4065: 0x0001, 0x4066: 0x0001, 0x4067: 0x0001, 0x4068: 0x0001, 0x4069: 0x0001, 0x406a: 0x0001, 0x406b: 0x0001, 0x406c: 0x0001, 0x406d: 0x0001, 0x406e: 0x0001, 0x406f: 0x0008, 0x4070: 0x0008, 0x4071: 0x0008, 0x4072: 0x0008, 0x4073: 0x0008, 0x4074: 0x0008, 0x4075: 0x0008, 0x4076: 0x0008, 0x4078: 0x0008, 0x4079: 0x0008, 0x407a: 0x0008, 0x407b: 0x0008, 0x407c: 0x0008, 0x407d: 0x0008, 0x407e: 0x0008, 0x407f: 0x0008, // Block 0x102, offset 0x4080 0x4080: 0x0001, 0x4090: 0x4000, 0x4091: 0x4000, 0x4092: 0x4000, 0x4093: 0x4000, 0x4094: 0x4000, 0x4095: 0x4000, 0x4096: 0x4000, 0x4097: 0x4000, 0x4098: 0x4000, 0x4099: 0x4000, 0x40b2: 0x0001, 0x40b3: 0x0001, 0x40b4: 0x0001, 0x40b5: 0x0001, 0x40b6: 0x0001, 0x40b7: 0x0001, 0x40b8: 0x0001, 0x40b9: 0x0001, 0x40ba: 0x0001, 0x40bb: 0x0001, 0x40bc: 0x0001, 0x40bd: 0x0001, 0x40be: 0x0001, 0x40bf: 0x0001, // Block 0x103, offset 0x40c0 0x40c0: 0x0001, 0x40c1: 0x0001, 0x40c2: 0x0001, 0x40c3: 0x0001, 0x40c4: 0x0001, 0x40c5: 0x0001, 0x40c6: 0x0001, 0x40c7: 0x0001, 0x40c8: 0x0001, 0x40c9: 0x0001, 0x40ca: 0x0001, 0x40cb: 0x0001, 0x40cc: 0x0001, 0x40cd: 0x0001, 0x40ce: 0x0001, 0x40cf: 0x0001, 0x40d2: 0x0008, 0x40d3: 0x0008, 0x40d4: 0x0008, 0x40d5: 0x0008, 0x40d6: 0x0008, 0x40d7: 0x0008, 0x40d8: 0x0008, 0x40d9: 0x0008, 0x40da: 0x0008, 0x40db: 0x0008, 0x40dc: 0x0008, 0x40dd: 0x0008, 0x40de: 0x0008, 0x40df: 0x0008, 0x40e0: 0x0008, 0x40e1: 0x0008, 0x40e2: 0x0008, 0x40e3: 0x0008, 0x40e4: 0x0008, 0x40e5: 0x0008, 0x40e6: 0x0008, 0x40e7: 0x0008, 0x40e9: 0x0008, 0x40ea: 0x0008, 0x40eb: 0x0008, 0x40ec: 0x0008, 0x40ed: 0x0008, 0x40ee: 0x0008, 0x40ef: 0x0008, 0x40f0: 0x0008, 0x40f1: 0x0008, 0x40f2: 0x0008, 0x40f3: 0x0008, 0x40f4: 0x0008, 0x40f5: 0x0008, 0x40f6: 0x0008, // Block 0x104, offset 0x4100 0x4100: 0x0001, 0x4101: 0x0001, 0x4102: 0x0001, 0x4103: 0x0001, 0x4104: 0x0001, 0x4105: 0x0001, 0x4106: 0x0001, 0x4108: 0x0001, 0x4109: 0x0001, 0x410b: 0x0001, 0x410c: 0x0001, 0x410d: 0x0001, 0x410e: 0x0001, 0x410f: 0x0001, 0x4110: 0x0001, 0x4111: 0x0001, 0x4112: 0x0001, 0x4113: 0x0001, 0x4114: 0x0001, 0x4115: 0x0001, 0x4116: 0x0001, 0x4117: 0x0001, 0x4118: 0x0001, 0x4119: 0x0001, 0x411a: 0x0001, 0x411b: 0x0001, 0x411c: 0x0001, 0x411d: 0x0001, 0x411e: 0x0001, 0x411f: 0x0001, 0x4120: 0x0001, 0x4121: 0x0001, 0x4122: 0x0001, 0x4123: 0x0001, 0x4124: 0x0001, 0x4125: 0x0001, 0x4126: 0x0001, 0x4127: 0x0001, 0x4128: 0x0001, 0x4129: 0x0001, 0x412a: 0x0001, 0x412b: 0x0001, 0x412c: 0x0001, 0x412d: 0x0001, 0x412e: 0x0001, 0x412f: 0x0001, 0x4130: 0x0001, 0x4131: 0x0008, 0x4132: 0x0008, 0x4133: 0x0008, 0x4134: 0x0008, 0x4135: 0x0008, 0x4136: 0x0008, 0x413a: 0x0008, 0x413c: 0x0008, 0x413d: 0x0008, 0x413f: 0x0008, // Block 0x105, offset 0x4140 0x4140: 0x0008, 0x4141: 0x0008, 0x4142: 0x0008, 0x4143: 0x0008, 0x4144: 0x0008, 0x4145: 0x0008, 0x4146: 0x0001, 0x4147: 0x0008, 0x4150: 0x4000, 0x4151: 0x4000, 0x4152: 0x4000, 0x4153: 0x4000, 0x4154: 0x4000, 0x4155: 0x4000, 0x4156: 0x4000, 0x4157: 0x4000, 0x4158: 0x4000, 0x4159: 0x4000, 0x4160: 0x0001, 0x4161: 0x0001, 0x4162: 0x0001, 0x4163: 0x0001, 0x4164: 0x0001, 0x4165: 0x0001, 0x4167: 0x0001, 0x4168: 0x0001, 0x416a: 0x0001, 0x416b: 0x0001, 0x416c: 0x0001, 0x416d: 0x0001, 0x416e: 0x0001, 0x416f: 0x0001, 0x4170: 0x0001, 0x4171: 0x0001, 0x4172: 0x0001, 0x4173: 0x0001, 0x4174: 0x0001, 0x4175: 0x0001, 0x4176: 0x0001, 0x4177: 0x0001, 0x4178: 0x0001, 0x4179: 0x0001, 0x417a: 0x0001, 0x417b: 0x0001, 0x417c: 0x0001, 0x417d: 0x0001, 0x417e: 0x0001, 0x417f: 0x0001, // Block 0x106, offset 0x4180 0x4180: 0x0001, 0x4181: 0x0001, 0x4182: 0x0001, 0x4183: 0x0001, 0x4184: 0x0001, 0x4185: 0x0001, 0x4186: 0x0001, 0x4187: 0x0001, 0x4188: 0x0001, 0x4189: 0x0001, 0x418a: 0x0008, 0x418b: 0x0008, 0x418c: 0x0008, 0x418d: 0x0008, 0x418e: 0x0008, 0x4190: 0x0008, 0x4191: 0x0008, 0x4193: 0x0008, 0x4194: 0x0008, 0x4195: 0x0008, 0x4196: 0x0008, 0x4197: 0x0008, 0x4198: 0x0001, 0x41a0: 0x4000, 0x41a1: 0x4000, 0x41a2: 0x4000, 0x41a3: 0x4000, 0x41a4: 0x4000, 0x41a5: 0x4000, 0x41a6: 0x4000, 0x41a7: 0x4000, 0x41a8: 0x4000, 0x41a9: 0x4000, 0x41b0: 0x0001, 0x41b1: 0x0001, 0x41b2: 0x0001, 0x41b3: 0x0001, 0x41b4: 0x0001, 0x41b5: 0x0001, 0x41b6: 0x0001, 0x41b7: 0x0001, 0x41b8: 0x0001, 0x41b9: 0x0001, 0x41ba: 0x0001, 0x41bb: 0x0001, 0x41bc: 0x0001, 0x41bd: 0x0001, 0x41be: 0x0001, 0x41bf: 0x0001, // Block 0x107, offset 0x41c0 0x41c0: 0x0001, 0x41c1: 0x0001, 0x41c2: 0x0001, 0x41c3: 0x0001, 0x41c4: 0x0001, 0x41c5: 0x0001, 0x41c6: 0x0001, 0x41c7: 0x0001, 0x41c8: 0x0001, 0x41c9: 0x0001, 0x41ca: 0x0001, 0x41cb: 0x0001, 0x41cc: 0x0001, 0x41cd: 0x0001, 0x41ce: 0x0001, 0x41cf: 0x0001, 0x41d0: 0x0001, 0x41d1: 0x0001, 0x41d2: 0x0001, 0x41d3: 0x0001, 0x41d4: 0x0001, 0x41d5: 0x0001, 0x41d6: 0x0001, 0x41d7: 0x0001, 0x41d8: 0x0001, 0x41d9: 0x0001, 0x41da: 0x0001, 0x41db: 0x0001, 0x41e0: 0x4000, 0x41e1: 0x4000, 0x41e2: 0x4000, 0x41e3: 0x4000, 0x41e4: 0x4000, 0x41e5: 0x4000, 0x41e6: 0x4000, 0x41e7: 0x4000, 0x41e8: 0x4000, 0x41e9: 0x4000, // Block 0x108, offset 0x4200 0x4220: 0x0001, 0x4221: 0x0001, 0x4222: 0x0001, 0x4223: 0x0001, 0x4224: 0x0001, 0x4225: 0x0001, 0x4226: 0x0001, 0x4227: 0x0001, 0x4228: 0x0001, 0x4229: 0x0001, 0x422a: 0x0001, 0x422b: 0x0001, 0x422c: 0x0001, 0x422d: 0x0001, 0x422e: 0x0001, 0x422f: 0x0001, 0x4230: 0x0001, 0x4231: 0x0001, 0x4232: 0x0001, 0x4233: 0x0008, 0x4234: 0x0008, 0x4235: 0x0008, 0x4236: 0x0008, // Block 0x109, offset 0x4240 0x4240: 0x0008, 0x4241: 0x0008, 0x4242: 0x0001, 0x4243: 0x0008, 0x4244: 0x0001, 0x4245: 0x0001, 0x4246: 0x0001, 0x4247: 0x0001, 0x4248: 0x0001, 0x4249: 0x0001, 0x424a: 0x0001, 0x424b: 0x0001, 0x424c: 0x0001, 0x424d: 0x0001, 0x424e: 0x0001, 0x424f: 0x0001, 0x4250: 0x0001, 0x4252: 0x0001, 0x4253: 0x0001, 0x4254: 0x0001, 0x4255: 0x0001, 0x4256: 0x0001, 0x4257: 0x0001, 0x4258: 0x0001, 0x4259: 0x0001, 0x425a: 0x0001, 0x425b: 0x0001, 0x425c: 0x0001, 0x425d: 0x0001, 0x425e: 0x0001, 0x425f: 0x0001, 0x4260: 0x0001, 0x4261: 0x0001, 0x4262: 0x0001, 0x4263: 0x0001, 0x4264: 0x0001, 0x4265: 0x0001, 0x4266: 0x0001, 0x4267: 0x0001, 0x4268: 0x0001, 0x4269: 0x0001, 0x426a: 0x0001, 0x426b: 0x0001, 0x426c: 0x0001, 0x426d: 0x0001, 0x426e: 0x0001, 0x426f: 0x0001, 0x4270: 0x0001, 0x4271: 0x0001, 0x4272: 0x0001, 0x4273: 0x0001, 0x4274: 0x0008, 0x4275: 0x0008, 0x4276: 0x0008, 0x4277: 0x0008, 0x4278: 0x0008, 0x4279: 0x0008, 0x427a: 0x0008, 0x427e: 0x0008, 0x427f: 0x0008, // Block 0x10a, offset 0x4280 0x4280: 0x0008, 0x4281: 0x0008, 0x4282: 0x0008, 0x4290: 0x4000, 0x4291: 0x4000, 0x4292: 0x4000, 0x4293: 0x4000, 0x4294: 0x4000, 0x4295: 0x4000, 0x4296: 0x4000, 0x4297: 0x4000, 0x4298: 0x4000, 0x4299: 0x4000, 0x429a: 0x0008, // Block 0x10b, offset 0x42c0 0x42f0: 0x0001, // Block 0x10c, offset 0x4300 0x4300: 0x0001, 0x4301: 0x0001, 0x4302: 0x0001, 0x4303: 0x0001, 0x4304: 0x0001, 0x4305: 0x0001, 0x4306: 0x0001, 0x4307: 0x0001, 0x4308: 0x0001, 0x4309: 0x0001, 0x430a: 0x0001, 0x430b: 0x0001, 0x430c: 0x0001, 0x430d: 0x0001, 0x430e: 0x0001, 0x430f: 0x0001, 0x4310: 0x0001, 0x4311: 0x0001, 0x4312: 0x0001, 0x4313: 0x0001, 0x4314: 0x0001, 0x4315: 0x0001, 0x4316: 0x0001, 0x4317: 0x0001, 0x4318: 0x0001, 0x4319: 0x0001, 0x431a: 0x0001, 0x431b: 0x0001, 0x431c: 0x0001, 0x431d: 0x0001, 0x431e: 0x0001, 0x431f: 0x0001, 0x4320: 0x0001, 0x4321: 0x0001, 0x4322: 0x0001, 0x4323: 0x0001, 0x4324: 0x0001, 0x4325: 0x0001, 0x4326: 0x0001, 0x4327: 0x0001, 0x4328: 0x0001, 0x4329: 0x0001, 0x432a: 0x0001, 0x432b: 0x0001, 0x432c: 0x0001, 0x432d: 0x0001, 0x432e: 0x0001, // Block 0x10d, offset 0x4340 0x4340: 0x0001, 0x4341: 0x0001, 0x4342: 0x0001, 0x4343: 0x0001, // Block 0x10e, offset 0x4380 0x4380: 0x0001, 0x4381: 0x0001, 0x4382: 0x0001, 0x4383: 0x0001, 0x4384: 0x0001, 0x4385: 0x0001, 0x4386: 0x0001, 0x4387: 0x0001, 0x4388: 0x0001, 0x4389: 0x0001, 0x438a: 0x0001, 0x438b: 0x0001, 0x438c: 0x0001, 0x438d: 0x0001, 0x438e: 0x0001, 0x438f: 0x0001, 0x4390: 0x0001, 0x4391: 0x0001, 0x4392: 0x0001, 0x4393: 0x0001, 0x4394: 0x0001, 0x4395: 0x0001, 0x4396: 0x0001, 0x4397: 0x0001, 0x4398: 0x0001, 0x4399: 0x0001, 0x439a: 0x0001, 0x439b: 0x0001, 0x439c: 0x0001, 0x439d: 0x0001, 0x439e: 0x0001, 0x439f: 0x0001, 0x43a0: 0x0001, 0x43a1: 0x0001, 0x43a2: 0x0001, 0x43a3: 0x0001, 0x43a4: 0x0001, 0x43a5: 0x0001, 0x43a6: 0x0001, 0x43a7: 0x0001, 0x43a8: 0x0001, 0x43a9: 0x0001, 0x43aa: 0x0001, 0x43ab: 0x0001, 0x43ac: 0x0001, 0x43ad: 0x0001, 0x43ae: 0x0001, 0x43af: 0x0001, 0x43b0: 0x0001, // Block 0x10f, offset 0x43c0 0x43c0: 0x0001, 0x43c1: 0x0001, 0x43c2: 0x0001, 0x43c3: 0x0001, 0x43c4: 0x0001, 0x43c5: 0x0001, 0x43c6: 0x0001, 0x43c7: 0x0001, 0x43c8: 0x0001, 0x43c9: 0x0001, 0x43ca: 0x0001, 0x43cb: 0x0001, 0x43cc: 0x0001, 0x43cd: 0x0001, 0x43ce: 0x0001, 0x43cf: 0x0001, 0x43d0: 0x0001, 0x43d1: 0x0001, 0x43d2: 0x0001, 0x43d3: 0x0001, 0x43d4: 0x0001, 0x43d5: 0x0001, 0x43d6: 0x0001, 0x43d7: 0x0001, 0x43d8: 0x0001, 0x43d9: 0x0001, 0x43da: 0x0001, 0x43db: 0x0001, 0x43dc: 0x0001, 0x43dd: 0x0001, 0x43de: 0x0001, 0x43df: 0x0001, 0x43e0: 0x0001, 0x43e1: 0x0001, 0x43e2: 0x0001, 0x43e3: 0x0001, 0x43e4: 0x0001, 0x43e5: 0x0001, 0x43e6: 0x0001, 0x43e7: 0x0001, 0x43e8: 0x0001, 0x43e9: 0x0001, 0x43ea: 0x0001, 0x43eb: 0x0001, 0x43ec: 0x0001, 0x43ed: 0x0001, 0x43ee: 0x0001, 0x43ef: 0x0001, 0x43f0: 0x0040, 0x43f1: 0x0040, 0x43f2: 0x0040, 0x43f3: 0x0040, 0x43f4: 0x0040, 0x43f5: 0x0040, 0x43f6: 0x0040, 0x43f7: 0x0040, 0x43f8: 0x0040, 0x43f9: 0x0040, 0x43fa: 0x0040, 0x43fb: 0x0040, 0x43fc: 0x0040, 0x43fd: 0x0040, 0x43fe: 0x0040, 0x43ff: 0x0040, // Block 0x110, offset 0x4400 0x4400: 0x0008, 0x4401: 0x0001, 0x4402: 0x0001, 0x4403: 0x0001, 0x4404: 0x0001, 0x4405: 0x0001, 0x4406: 0x0001, 0x4407: 0x0008, 0x4408: 0x0008, 0x4409: 0x0008, 0x440a: 0x0008, 0x440b: 0x0008, 0x440c: 0x0008, 0x440d: 0x0008, 0x440e: 0x0008, 0x440f: 0x0008, 0x4410: 0x0008, 0x4411: 0x0008, 0x4412: 0x0008, 0x4413: 0x0008, 0x4414: 0x0008, 0x4415: 0x0008, 0x4420: 0x0001, 0x4421: 0x0001, 0x4422: 0x0001, 0x4423: 0x0001, 0x4424: 0x0001, 0x4425: 0x0001, 0x4426: 0x0001, 0x4427: 0x0001, 0x4428: 0x0001, 0x4429: 0x0001, 0x442a: 0x0001, 0x442b: 0x0001, 0x442c: 0x0001, 0x442d: 0x0001, 0x442e: 0x0001, 0x442f: 0x0001, 0x4430: 0x0001, 0x4431: 0x0001, 0x4432: 0x0001, 0x4433: 0x0001, 0x4434: 0x0001, 0x4435: 0x0001, 0x4436: 0x0001, 0x4437: 0x0001, 0x4438: 0x0001, 0x4439: 0x0001, 0x443a: 0x0001, 0x443b: 0x0001, 0x443c: 0x0001, 0x443d: 0x0001, 0x443e: 0x0001, 0x443f: 0x0001, // Block 0x111, offset 0x4440 0x4440: 0x0001, 0x4441: 0x0001, 0x4442: 0x0001, 0x4443: 0x0001, 0x4444: 0x0001, 0x4445: 0x0001, 0x4446: 0x0001, // Block 0x112, offset 0x4480 0x4480: 0x0001, 0x4481: 0x0001, 0x4482: 0x0001, 0x4483: 0x0001, 0x4484: 0x0001, 0x4485: 0x0001, 0x4486: 0x0001, 0x4487: 0x0001, 0x4488: 0x0001, 0x4489: 0x0001, 0x448a: 0x0001, 0x448b: 0x0001, 0x448c: 0x0001, 0x448d: 0x0001, 0x448e: 0x0001, 0x448f: 0x0001, 0x4490: 0x0001, 0x4491: 0x0001, 0x4492: 0x0001, 0x4493: 0x0001, 0x4494: 0x0001, 0x4495: 0x0001, 0x4496: 0x0001, 0x4497: 0x0001, 0x4498: 0x0001, 0x4499: 0x0001, 0x449a: 0x0001, 0x449b: 0x0001, 0x449c: 0x0001, 0x449d: 0x0001, 0x449e: 0x0008, 0x449f: 0x0008, 0x44a0: 0x0008, 0x44a1: 0x0008, 0x44a2: 0x0008, 0x44a3: 0x0008, 0x44a4: 0x0008, 0x44a5: 0x0008, 0x44a6: 0x0008, 0x44a7: 0x0008, 0x44a8: 0x0008, 0x44a9: 0x0008, 0x44aa: 0x0008, 0x44ab: 0x0008, 0x44ac: 0x0008, 0x44ad: 0x0008, 0x44ae: 0x0008, 0x44af: 0x0008, 0x44b0: 0x4000, 0x44b1: 0x4000, 0x44b2: 0x4000, 0x44b3: 0x4000, 0x44b4: 0x4000, 0x44b5: 0x4000, 0x44b6: 0x4000, 0x44b7: 0x4000, 0x44b8: 0x4000, 0x44b9: 0x4000, // Block 0x113, offset 0x44c0 0x44c0: 0x0001, 0x44c1: 0x0001, 0x44c2: 0x0001, 0x44c3: 0x0001, 0x44c4: 0x0001, 0x44c5: 0x0001, 0x44c6: 0x0001, 0x44c7: 0x0001, 0x44c8: 0x0001, 0x44c9: 0x0001, 0x44ca: 0x0001, 0x44cb: 0x0001, 0x44cc: 0x0001, 0x44cd: 0x0001, 0x44ce: 0x0001, 0x44cf: 0x0001, 0x44d0: 0x0001, 0x44d1: 0x0001, 0x44d2: 0x0001, 0x44d3: 0x0001, 0x44d4: 0x0001, 0x44d5: 0x0001, 0x44d6: 0x0001, 0x44d7: 0x0001, 0x44d8: 0x0001, 0x44d9: 0x0001, 0x44da: 0x0001, 0x44db: 0x0001, 0x44dc: 0x0001, 0x44dd: 0x0001, 0x44de: 0x0001, 0x44e0: 0x4000, 0x44e1: 0x4000, 0x44e2: 0x4000, 0x44e3: 0x4000, 0x44e4: 0x4000, 0x44e5: 0x4000, 0x44e6: 0x4000, 0x44e7: 0x4000, 0x44e8: 0x4000, 0x44e9: 0x4000, 0x44f0: 0x0001, 0x44f1: 0x0001, 0x44f2: 0x0001, 0x44f3: 0x0001, 0x44f4: 0x0001, 0x44f5: 0x0001, 0x44f6: 0x0001, 0x44f7: 0x0001, 0x44f8: 0x0001, 0x44f9: 0x0001, 0x44fa: 0x0001, 0x44fb: 0x0001, 0x44fc: 0x0001, 0x44fd: 0x0001, 0x44fe: 0x0001, 0x44ff: 0x0001, // Block 0x114, offset 0x4500 0x4500: 0x0001, 0x4501: 0x0001, 0x4502: 0x0001, 0x4503: 0x0001, 0x4504: 0x0001, 0x4505: 0x0001, 0x4506: 0x0001, 0x4507: 0x0001, 0x4508: 0x0001, 0x4509: 0x0001, 0x450a: 0x0001, 0x450b: 0x0001, 0x450c: 0x0001, 0x450d: 0x0001, 0x450e: 0x0001, 0x450f: 0x0001, 0x4510: 0x0001, 0x4511: 0x0001, 0x4512: 0x0001, 0x4513: 0x0001, 0x4514: 0x0001, 0x4515: 0x0001, 0x4516: 0x0001, 0x4517: 0x0001, 0x4518: 0x0001, 0x4519: 0x0001, 0x451a: 0x0001, 0x451b: 0x0001, 0x451c: 0x0001, 0x451d: 0x0001, 0x451e: 0x0001, 0x451f: 0x0001, 0x4520: 0x0001, 0x4521: 0x0001, 0x4522: 0x0001, 0x4523: 0x0001, 0x4524: 0x0001, 0x4525: 0x0001, 0x4526: 0x0001, 0x4527: 0x0001, 0x4528: 0x0001, 0x4529: 0x0001, 0x452a: 0x0001, 0x452b: 0x0001, 0x452c: 0x0001, 0x452d: 0x0001, 0x452e: 0x0001, 0x452f: 0x0001, 0x4530: 0x0001, 0x4531: 0x0001, 0x4532: 0x0001, 0x4533: 0x0001, 0x4534: 0x0001, 0x4535: 0x0001, 0x4536: 0x0001, 0x4537: 0x0001, 0x4538: 0x0001, 0x4539: 0x0001, 0x453a: 0x0001, 0x453b: 0x0001, 0x453c: 0x0001, 0x453d: 0x0001, 0x453e: 0x0001, // Block 0x115, offset 0x4540 0x4540: 0x4000, 0x4541: 0x4000, 0x4542: 0x4000, 0x4543: 0x4000, 0x4544: 0x4000, 0x4545: 0x4000, 0x4546: 0x4000, 0x4547: 0x4000, 0x4548: 0x4000, 0x4549: 0x4000, 0x4550: 0x0001, 0x4551: 0x0001, 0x4552: 0x0001, 0x4553: 0x0001, 0x4554: 0x0001, 0x4555: 0x0001, 0x4556: 0x0001, 0x4557: 0x0001, 0x4558: 0x0001, 0x4559: 0x0001, 0x455a: 0x0001, 0x455b: 0x0001, 0x455c: 0x0001, 0x455d: 0x0001, 0x455e: 0x0001, 0x455f: 0x0001, 0x4560: 0x0001, 0x4561: 0x0001, 0x4562: 0x0001, 0x4563: 0x0001, 0x4564: 0x0001, 0x4565: 0x0001, 0x4566: 0x0001, 0x4567: 0x0001, 0x4568: 0x0001, 0x4569: 0x0001, 0x456a: 0x0001, 0x456b: 0x0001, 0x456c: 0x0001, 0x456d: 0x0001, 0x4570: 0x0008, 0x4571: 0x0008, 0x4572: 0x0008, 0x4573: 0x0008, 0x4574: 0x0008, // Block 0x116, offset 0x4580 0x4580: 0x0001, 0x4581: 0x0001, 0x4582: 0x0001, 0x4583: 0x0001, 0x4584: 0x0001, 0x4585: 0x0001, 0x4586: 0x0001, 0x4587: 0x0001, 0x4588: 0x0001, 0x4589: 0x0001, 0x458a: 0x0001, 0x458b: 0x0001, 0x458c: 0x0001, 0x458d: 0x0001, 0x458e: 0x0001, 0x458f: 0x0001, 0x4590: 0x0001, 0x4591: 0x0001, 0x4592: 0x0001, 0x4593: 0x0001, 0x4594: 0x0001, 0x4595: 0x0001, 0x4596: 0x0001, 0x4597: 0x0001, 0x4598: 0x0001, 0x4599: 0x0001, 0x459a: 0x0001, 0x459b: 0x0001, 0x459c: 0x0001, 0x459d: 0x0001, 0x459e: 0x0001, 0x459f: 0x0001, 0x45a0: 0x0001, 0x45a1: 0x0001, 0x45a2: 0x0001, 0x45a3: 0x0001, 0x45a4: 0x0001, 0x45a5: 0x0001, 0x45a6: 0x0001, 0x45a7: 0x0001, 0x45a8: 0x0001, 0x45a9: 0x0001, 0x45aa: 0x0001, 0x45ab: 0x0001, 0x45ac: 0x0001, 0x45ad: 0x0001, 0x45ae: 0x0001, 0x45af: 0x0001, 0x45b0: 0x0008, 0x45b1: 0x0008, 0x45b2: 0x0008, 0x45b3: 0x0008, 0x45b4: 0x0008, 0x45b5: 0x0008, 0x45b6: 0x0008, // Block 0x117, offset 0x45c0 0x45c0: 0x0001, 0x45c1: 0x0001, 0x45c2: 0x0001, 0x45c3: 0x0001, 0x45d0: 0x4000, 0x45d1: 0x4000, 0x45d2: 0x4000, 0x45d3: 0x4000, 0x45d4: 0x4000, 0x45d5: 0x4000, 0x45d6: 0x4000, 0x45d7: 0x4000, 0x45d8: 0x4000, 0x45d9: 0x4000, 0x45e3: 0x0001, 0x45e4: 0x0001, 0x45e5: 0x0001, 0x45e6: 0x0001, 0x45e7: 0x0001, 0x45e8: 0x0001, 0x45e9: 0x0001, 0x45ea: 0x0001, 0x45eb: 0x0001, 0x45ec: 0x0001, 0x45ed: 0x0001, 0x45ee: 0x0001, 0x45ef: 0x0001, 0x45f0: 0x0001, 0x45f1: 0x0001, 0x45f2: 0x0001, 0x45f3: 0x0001, 0x45f4: 0x0001, 0x45f5: 0x0001, 0x45f6: 0x0001, 0x45f7: 0x0001, 0x45fd: 0x0001, 0x45fe: 0x0001, 0x45ff: 0x0001, // Block 0x118, offset 0x4600 0x4600: 0x0001, 0x4601: 0x0001, 0x4602: 0x0001, 0x4603: 0x0001, 0x4604: 0x0001, 0x4605: 0x0001, 0x4606: 0x0001, 0x4607: 0x0001, 0x4608: 0x0001, 0x4609: 0x0001, 0x460a: 0x0001, 0x460b: 0x0001, 0x460c: 0x0001, 0x460d: 0x0001, 0x460e: 0x0001, 0x460f: 0x0001, // Block 0x119, offset 0x4640 0x4640: 0x0001, 0x4641: 0x0001, 0x4642: 0x0001, 0x4643: 0x0001, 0x4644: 0x0001, 0x4645: 0x0001, 0x4646: 0x0001, 0x4647: 0x0001, 0x4648: 0x0001, 0x4649: 0x0001, 0x464a: 0x0001, 0x464b: 0x0001, 0x464c: 0x0001, 0x464d: 0x0001, 0x464e: 0x0001, 0x464f: 0x0001, 0x4650: 0x0001, 0x4651: 0x0001, 0x4652: 0x0001, 0x4653: 0x0001, 0x4654: 0x0001, 0x4655: 0x0001, 0x4656: 0x0001, 0x4657: 0x0001, 0x4658: 0x0001, 0x4659: 0x0001, 0x465a: 0x0001, 0x465b: 0x0001, 0x465c: 0x0001, 0x465d: 0x0001, 0x465e: 0x0001, 0x465f: 0x0001, 0x4660: 0x0001, 0x4661: 0x0001, 0x4662: 0x0001, 0x4663: 0x0001, 0x4664: 0x0001, 0x4665: 0x0001, 0x4666: 0x0001, 0x4667: 0x0001, 0x4668: 0x0001, 0x4669: 0x0001, 0x466a: 0x0001, 0x466b: 0x0001, 0x466c: 0x0001, 0x4670: 0x4000, 0x4671: 0x4000, 0x4672: 0x4000, 0x4673: 0x4000, 0x4674: 0x4000, 0x4675: 0x4000, 0x4676: 0x4000, 0x4677: 0x4000, 0x4678: 0x4000, 0x4679: 0x4000, // Block 0x11a, offset 0x4680 0x46a0: 0x0001, 0x46a1: 0x0001, 0x46a2: 0x0001, 0x46a3: 0x0001, 0x46a4: 0x0001, 0x46a5: 0x0001, 0x46a6: 0x0001, 0x46a7: 0x0001, 0x46a8: 0x0001, 0x46a9: 0x0001, 0x46aa: 0x0001, 0x46ab: 0x0001, 0x46ac: 0x0001, 0x46ad: 0x0001, 0x46ae: 0x0001, 0x46af: 0x0001, 0x46b0: 0x0001, 0x46b1: 0x0001, 0x46b2: 0x0001, 0x46b3: 0x0001, 0x46b4: 0x0001, 0x46b5: 0x0001, 0x46b6: 0x0001, 0x46b7: 0x0001, 0x46b8: 0x0001, 0x46bb: 0x0001, 0x46bc: 0x0001, 0x46bd: 0x0001, 0x46be: 0x0001, 0x46bf: 0x0001, // Block 0x11b, offset 0x46c0 0x46c0: 0x0001, 0x46c1: 0x0001, 0x46c2: 0x0001, 0x46c3: 0x0001, 0x46c4: 0x0001, 0x46c5: 0x0001, 0x46c6: 0x0001, 0x46c7: 0x0001, 0x46c8: 0x0001, 0x46c9: 0x0001, 0x46ca: 0x0001, 0x46cb: 0x0001, 0x46cc: 0x0001, 0x46cd: 0x0001, 0x46ce: 0x0001, 0x46cf: 0x0001, 0x46d0: 0x0001, 0x46d1: 0x0001, 0x46d2: 0x0001, 0x46d3: 0x0001, // Block 0x11c, offset 0x4700 0x4700: 0x0001, 0x4701: 0x0001, 0x4702: 0x0001, 0x4703: 0x0001, 0x4704: 0x0001, 0x4705: 0x0001, 0x4706: 0x0001, 0x4707: 0x0001, 0x4708: 0x0001, 0x4709: 0x0001, 0x470a: 0x0001, 0x470f: 0x0008, 0x4710: 0x0001, 0x4711: 0x0008, 0x4712: 0x0008, 0x4713: 0x0008, 0x4714: 0x0008, 0x4715: 0x0008, 0x4716: 0x0008, 0x4717: 0x0008, 0x4718: 0x0008, 0x4719: 0x0008, 0x471a: 0x0008, 0x471b: 0x0008, 0x471c: 0x0008, 0x471d: 0x0008, 0x471e: 0x0008, 0x471f: 0x0008, 0x4720: 0x0008, 0x4721: 0x0008, 0x4722: 0x0008, 0x4723: 0x0008, 0x4724: 0x0008, 0x4725: 0x0008, 0x4726: 0x0008, 0x4727: 0x0008, 0x4728: 0x0008, 0x4729: 0x0008, 0x472a: 0x0008, 0x472b: 0x0008, 0x472c: 0x0008, 0x472d: 0x0008, 0x472e: 0x0008, 0x472f: 0x0008, 0x4730: 0x0008, 0x4731: 0x0008, 0x4732: 0x0008, 0x4733: 0x0008, 0x4734: 0x0008, 0x4735: 0x0008, 0x4736: 0x0008, 0x4737: 0x0008, 0x4738: 0x0008, 0x4739: 0x0008, 0x473a: 0x0008, 0x473b: 0x0008, 0x473c: 0x0008, 0x473d: 0x0008, 0x473e: 0x0008, 0x473f: 0x0008, // Block 0x11d, offset 0x4740 0x4740: 0x0008, 0x4741: 0x0008, 0x4742: 0x0008, 0x4743: 0x0008, 0x4744: 0x0008, 0x4745: 0x0008, 0x4746: 0x0008, 0x4747: 0x0008, 0x474f: 0x0008, 0x4750: 0x0008, 0x4751: 0x0008, 0x4752: 0x0008, 0x4753: 0x0001, 0x4754: 0x0001, 0x4755: 0x0001, 0x4756: 0x0001, 0x4757: 0x0001, 0x4758: 0x0001, 0x4759: 0x0001, 0x475a: 0x0001, 0x475b: 0x0001, 0x475c: 0x0001, 0x475d: 0x0001, 0x475e: 0x0001, 0x475f: 0x0001, // Block 0x11e, offset 0x4780 0x47a0: 0x0001, 0x47a1: 0x0001, 0x47a3: 0x0001, 0x47a4: 0x0008, 0x47b0: 0x0008, 0x47b1: 0x0008, // Block 0x11f, offset 0x47c0 0x47f0: 0x0100, 0x47f1: 0x0100, 0x47f2: 0x0100, 0x47f3: 0x0100, 0x47f5: 0x0100, 0x47f6: 0x0100, 0x47f7: 0x0100, 0x47f8: 0x0100, 0x47f9: 0x0100, 0x47fa: 0x0100, 0x47fb: 0x0100, 0x47fd: 0x0100, 0x47fe: 0x0100, // Block 0x120, offset 0x4800 0x4800: 0x0100, // Block 0x121, offset 0x4840 0x4860: 0x0100, 0x4861: 0x0100, 0x4862: 0x0100, // Block 0x122, offset 0x4880 0x4895: 0x0100, 0x48a4: 0x0100, 0x48a5: 0x0100, 0x48a6: 0x0100, 0x48a7: 0x0100, // Block 0x123, offset 0x48c0 0x48c0: 0x0001, 0x48c1: 0x0001, 0x48c2: 0x0001, 0x48c3: 0x0001, 0x48c4: 0x0001, 0x48c5: 0x0001, 0x48c6: 0x0001, 0x48c7: 0x0001, 0x48c8: 0x0001, 0x48c9: 0x0001, 0x48ca: 0x0001, 0x48cb: 0x0001, 0x48cc: 0x0001, 0x48cd: 0x0001, 0x48ce: 0x0001, 0x48cf: 0x0001, 0x48d0: 0x0001, 0x48d1: 0x0001, 0x48d2: 0x0001, 0x48d3: 0x0001, 0x48d4: 0x0001, 0x48d5: 0x0001, 0x48d6: 0x0001, 0x48d7: 0x0001, 0x48d8: 0x0001, 0x48d9: 0x0001, 0x48da: 0x0001, 0x48db: 0x0001, 0x48dc: 0x0001, 0x48dd: 0x0001, 0x48de: 0x0001, 0x48df: 0x0001, 0x48e0: 0x0001, 0x48e1: 0x0001, 0x48e2: 0x0001, 0x48e3: 0x0001, 0x48e4: 0x0001, 0x48e5: 0x0001, 0x48e6: 0x0001, 0x48e7: 0x0001, 0x48e8: 0x0001, 0x48e9: 0x0001, 0x48ea: 0x0001, 0x48f0: 0x0001, 0x48f1: 0x0001, 0x48f2: 0x0001, 0x48f3: 0x0001, 0x48f4: 0x0001, 0x48f5: 0x0001, 0x48f6: 0x0001, 0x48f7: 0x0001, 0x48f8: 0x0001, 0x48f9: 0x0001, 0x48fa: 0x0001, 0x48fb: 0x0001, 0x48fc: 0x0001, // Block 0x124, offset 0x4900 0x4900: 0x0001, 0x4901: 0x0001, 0x4902: 0x0001, 0x4903: 0x0001, 0x4904: 0x0001, 0x4905: 0x0001, 0x4906: 0x0001, 0x4907: 0x0001, 0x4908: 0x0001, 0x4910: 0x0001, 0x4911: 0x0001, 0x4912: 0x0001, 0x4913: 0x0001, 0x4914: 0x0001, 0x4915: 0x0001, 0x4916: 0x0001, 0x4917: 0x0001, 0x4918: 0x0001, 0x4919: 0x0001, 0x491d: 0x0008, 0x491e: 0x0008, 0x4920: 0x0040, 0x4921: 0x0040, 0x4922: 0x0040, 0x4923: 0x0040, // Block 0x125, offset 0x4940 0x4970: 0x4000, 0x4971: 0x4000, 0x4972: 0x4000, 0x4973: 0x4000, 0x4974: 0x4000, 0x4975: 0x4000, 0x4976: 0x4000, 0x4977: 0x4000, 0x4978: 0x4000, 0x4979: 0x4000, // Block 0x126, offset 0x4980 0x4980: 0x0008, 0x4981: 0x0008, 0x4982: 0x0008, 0x4983: 0x0008, 0x4984: 0x0008, 0x4985: 0x0008, 0x4986: 0x0008, 0x4987: 0x0008, 0x4988: 0x0008, 0x4989: 0x0008, 0x498a: 0x0008, 0x498b: 0x0008, 0x498c: 0x0008, 0x498d: 0x0008, 0x498e: 0x0008, 0x498f: 0x0008, 0x4990: 0x0008, 0x4991: 0x0008, 0x4992: 0x0008, 0x4993: 0x0008, 0x4994: 0x0008, 0x4995: 0x0008, 0x4996: 0x0008, 0x4997: 0x0008, 0x4998: 0x0008, 0x4999: 0x0008, 0x499a: 0x0008, 0x499b: 0x0008, 0x499c: 0x0008, 0x499d: 0x0008, 0x499e: 0x0008, 0x499f: 0x0008, 0x49a0: 0x0008, 0x49a1: 0x0008, 0x49a2: 0x0008, 0x49a3: 0x0008, 0x49a4: 0x0008, 0x49a5: 0x0008, 0x49a6: 0x0008, 0x49a7: 0x0008, 0x49a8: 0x0008, 0x49a9: 0x0008, 0x49aa: 0x0008, 0x49ab: 0x0008, 0x49ac: 0x0008, 0x49ad: 0x0008, 0x49b0: 0x0008, 0x49b1: 0x0008, 0x49b2: 0x0008, 0x49b3: 0x0008, 0x49b4: 0x0008, 0x49b5: 0x0008, 0x49b6: 0x0008, 0x49b7: 0x0008, 0x49b8: 0x0008, 0x49b9: 0x0008, 0x49ba: 0x0008, 0x49bb: 0x0008, 0x49bc: 0x0008, 0x49bd: 0x0008, 0x49be: 0x0008, 0x49bf: 0x0008, // Block 0x127, offset 0x49c0 0x49c0: 0x0008, 0x49c1: 0x0008, 0x49c2: 0x0008, 0x49c3: 0x0008, 0x49c4: 0x0008, 0x49c5: 0x0008, 0x49c6: 0x0008, // Block 0x128, offset 0x4a00 0x4a25: 0x0008, 0x4a26: 0x0008, 0x4a27: 0x0008, 0x4a28: 0x0008, 0x4a29: 0x0008, 0x4a2d: 0x0008, 0x4a2e: 0x0008, 0x4a2f: 0x0008, 0x4a30: 0x0008, 0x4a31: 0x0008, 0x4a32: 0x0008, 0x4a33: 0x0040, 0x4a34: 0x0040, 0x4a35: 0x0040, 0x4a36: 0x0040, 0x4a37: 0x0040, 0x4a38: 0x0040, 0x4a39: 0x0040, 0x4a3a: 0x0040, 0x4a3b: 0x0008, 0x4a3c: 0x0008, 0x4a3d: 0x0008, 0x4a3e: 0x0008, 0x4a3f: 0x0008, // Block 0x129, offset 0x4a40 0x4a40: 0x0008, 0x4a41: 0x0008, 0x4a42: 0x0008, 0x4a45: 0x0008, 0x4a46: 0x0008, 0x4a47: 0x0008, 0x4a48: 0x0008, 0x4a49: 0x0008, 0x4a4a: 0x0008, 0x4a4b: 0x0008, 0x4a6a: 0x0008, 0x4a6b: 0x0008, 0x4a6c: 0x0008, 0x4a6d: 0x0008, // Block 0x12a, offset 0x4a80 0x4a82: 0x0008, 0x4a83: 0x0008, 0x4a84: 0x0008, // Block 0x12b, offset 0x4ac0 0x4ac0: 0x0001, 0x4ac1: 0x0001, 0x4ac2: 0x0001, 0x4ac3: 0x0001, 0x4ac4: 0x0001, 0x4ac5: 0x0001, 0x4ac6: 0x0001, 0x4ac7: 0x0001, 0x4ac8: 0x0001, 0x4ac9: 0x0001, 0x4aca: 0x0001, 0x4acb: 0x0001, 0x4acc: 0x0001, 0x4acd: 0x0001, 0x4ace: 0x0001, 0x4acf: 0x0001, 0x4ad0: 0x0001, 0x4ad1: 0x0001, 0x4ad2: 0x0001, 0x4ad3: 0x0001, 0x4ad4: 0x0001, 0x4ad6: 0x0001, 0x4ad7: 0x0001, 0x4ad8: 0x0001, 0x4ad9: 0x0001, 0x4ada: 0x0001, 0x4adb: 0x0001, 0x4adc: 0x0001, 0x4add: 0x0001, 0x4ade: 0x0001, 0x4adf: 0x0001, 0x4ae0: 0x0001, 0x4ae1: 0x0001, 0x4ae2: 0x0001, 0x4ae3: 0x0001, 0x4ae4: 0x0001, 0x4ae5: 0x0001, 0x4ae6: 0x0001, 0x4ae7: 0x0001, 0x4ae8: 0x0001, 0x4ae9: 0x0001, 0x4aea: 0x0001, 0x4aeb: 0x0001, 0x4aec: 0x0001, 0x4aed: 0x0001, 0x4aee: 0x0001, 0x4aef: 0x0001, 0x4af0: 0x0001, 0x4af1: 0x0001, 0x4af2: 0x0001, 0x4af3: 0x0001, 0x4af4: 0x0001, 0x4af5: 0x0001, 0x4af6: 0x0001, 0x4af7: 0x0001, 0x4af8: 0x0001, 0x4af9: 0x0001, 0x4afa: 0x0001, 0x4afb: 0x0001, 0x4afc: 0x0001, 0x4afd: 0x0001, 0x4afe: 0x0001, 0x4aff: 0x0001, // Block 0x12c, offset 0x4b00 0x4b00: 0x0001, 0x4b01: 0x0001, 0x4b02: 0x0001, 0x4b03: 0x0001, 0x4b04: 0x0001, 0x4b05: 0x0001, 0x4b06: 0x0001, 0x4b07: 0x0001, 0x4b08: 0x0001, 0x4b09: 0x0001, 0x4b0a: 0x0001, 0x4b0b: 0x0001, 0x4b0c: 0x0001, 0x4b0d: 0x0001, 0x4b0e: 0x0001, 0x4b0f: 0x0001, 0x4b10: 0x0001, 0x4b11: 0x0001, 0x4b12: 0x0001, 0x4b13: 0x0001, 0x4b14: 0x0001, 0x4b15: 0x0001, 0x4b16: 0x0001, 0x4b17: 0x0001, 0x4b18: 0x0001, 0x4b19: 0x0001, 0x4b1a: 0x0001, 0x4b1b: 0x0001, 0x4b1c: 0x0001, 0x4b1e: 0x0001, 0x4b1f: 0x0001, 0x4b22: 0x0001, 0x4b25: 0x0001, 0x4b26: 0x0001, 0x4b29: 0x0001, 0x4b2a: 0x0001, 0x4b2b: 0x0001, 0x4b2c: 0x0001, 0x4b2e: 0x0001, 0x4b2f: 0x0001, 0x4b30: 0x0001, 0x4b31: 0x0001, 0x4b32: 0x0001, 0x4b33: 0x0001, 0x4b34: 0x0001, 0x4b35: 0x0001, 0x4b36: 0x0001, 0x4b37: 0x0001, 0x4b38: 0x0001, 0x4b39: 0x0001, 0x4b3b: 0x0001, 0x4b3d: 0x0001, 0x4b3e: 0x0001, 0x4b3f: 0x0001, // Block 0x12d, offset 0x4b40 0x4b40: 0x0001, 0x4b41: 0x0001, 0x4b42: 0x0001, 0x4b43: 0x0001, 0x4b45: 0x0001, 0x4b46: 0x0001, 0x4b47: 0x0001, 0x4b48: 0x0001, 0x4b49: 0x0001, 0x4b4a: 0x0001, 0x4b4b: 0x0001, 0x4b4c: 0x0001, 0x4b4d: 0x0001, 0x4b4e: 0x0001, 0x4b4f: 0x0001, 0x4b50: 0x0001, 0x4b51: 0x0001, 0x4b52: 0x0001, 0x4b53: 0x0001, 0x4b54: 0x0001, 0x4b55: 0x0001, 0x4b56: 0x0001, 0x4b57: 0x0001, 0x4b58: 0x0001, 0x4b59: 0x0001, 0x4b5a: 0x0001, 0x4b5b: 0x0001, 0x4b5c: 0x0001, 0x4b5d: 0x0001, 0x4b5e: 0x0001, 0x4b5f: 0x0001, 0x4b60: 0x0001, 0x4b61: 0x0001, 0x4b62: 0x0001, 0x4b63: 0x0001, 0x4b64: 0x0001, 0x4b65: 0x0001, 0x4b66: 0x0001, 0x4b67: 0x0001, 0x4b68: 0x0001, 0x4b69: 0x0001, 0x4b6a: 0x0001, 0x4b6b: 0x0001, 0x4b6c: 0x0001, 0x4b6d: 0x0001, 0x4b6e: 0x0001, 0x4b6f: 0x0001, 0x4b70: 0x0001, 0x4b71: 0x0001, 0x4b72: 0x0001, 0x4b73: 0x0001, 0x4b74: 0x0001, 0x4b75: 0x0001, 0x4b76: 0x0001, 0x4b77: 0x0001, 0x4b78: 0x0001, 0x4b79: 0x0001, 0x4b7a: 0x0001, 0x4b7b: 0x0001, 0x4b7c: 0x0001, 0x4b7d: 0x0001, 0x4b7e: 0x0001, 0x4b7f: 0x0001, // Block 0x12e, offset 0x4b80 0x4b80: 0x0001, 0x4b81: 0x0001, 0x4b82: 0x0001, 0x4b83: 0x0001, 0x4b84: 0x0001, 0x4b85: 0x0001, 0x4b87: 0x0001, 0x4b88: 0x0001, 0x4b89: 0x0001, 0x4b8a: 0x0001, 0x4b8d: 0x0001, 0x4b8e: 0x0001, 0x4b8f: 0x0001, 0x4b90: 0x0001, 0x4b91: 0x0001, 0x4b92: 0x0001, 0x4b93: 0x0001, 0x4b94: 0x0001, 0x4b96: 0x0001, 0x4b97: 0x0001, 0x4b98: 0x0001, 0x4b99: 0x0001, 0x4b9a: 0x0001, 0x4b9b: 0x0001, 0x4b9c: 0x0001, 0x4b9e: 0x0001, 0x4b9f: 0x0001, 0x4ba0: 0x0001, 0x4ba1: 0x0001, 0x4ba2: 0x0001, 0x4ba3: 0x0001, 0x4ba4: 0x0001, 0x4ba5: 0x0001, 0x4ba6: 0x0001, 0x4ba7: 0x0001, 0x4ba8: 0x0001, 0x4ba9: 0x0001, 0x4baa: 0x0001, 0x4bab: 0x0001, 0x4bac: 0x0001, 0x4bad: 0x0001, 0x4bae: 0x0001, 0x4baf: 0x0001, 0x4bb0: 0x0001, 0x4bb1: 0x0001, 0x4bb2: 0x0001, 0x4bb3: 0x0001, 0x4bb4: 0x0001, 0x4bb5: 0x0001, 0x4bb6: 0x0001, 0x4bb7: 0x0001, 0x4bb8: 0x0001, 0x4bb9: 0x0001, 0x4bbb: 0x0001, 0x4bbc: 0x0001, 0x4bbd: 0x0001, 0x4bbe: 0x0001, // Block 0x12f, offset 0x4bc0 0x4bc0: 0x0001, 0x4bc1: 0x0001, 0x4bc2: 0x0001, 0x4bc3: 0x0001, 0x4bc4: 0x0001, 0x4bc6: 0x0001, 0x4bca: 0x0001, 0x4bcb: 0x0001, 0x4bcc: 0x0001, 0x4bcd: 0x0001, 0x4bce: 0x0001, 0x4bcf: 0x0001, 0x4bd0: 0x0001, 0x4bd2: 0x0001, 0x4bd3: 0x0001, 0x4bd4: 0x0001, 0x4bd5: 0x0001, 0x4bd6: 0x0001, 0x4bd7: 0x0001, 0x4bd8: 0x0001, 0x4bd9: 0x0001, 0x4bda: 0x0001, 0x4bdb: 0x0001, 0x4bdc: 0x0001, 0x4bdd: 0x0001, 0x4bde: 0x0001, 0x4bdf: 0x0001, 0x4be0: 0x0001, 0x4be1: 0x0001, 0x4be2: 0x0001, 0x4be3: 0x0001, 0x4be4: 0x0001, 0x4be5: 0x0001, 0x4be6: 0x0001, 0x4be7: 0x0001, 0x4be8: 0x0001, 0x4be9: 0x0001, 0x4bea: 0x0001, 0x4beb: 0x0001, 0x4bec: 0x0001, 0x4bed: 0x0001, 0x4bee: 0x0001, 0x4bef: 0x0001, 0x4bf0: 0x0001, 0x4bf1: 0x0001, 0x4bf2: 0x0001, 0x4bf3: 0x0001, 0x4bf4: 0x0001, 0x4bf5: 0x0001, 0x4bf6: 0x0001, 0x4bf7: 0x0001, 0x4bf8: 0x0001, 0x4bf9: 0x0001, 0x4bfa: 0x0001, 0x4bfb: 0x0001, 0x4bfc: 0x0001, 0x4bfd: 0x0001, 0x4bfe: 0x0001, 0x4bff: 0x0001, // Block 0x130, offset 0x4c00 0x4c00: 0x0001, 0x4c01: 0x0001, 0x4c02: 0x0001, 0x4c03: 0x0001, 0x4c04: 0x0001, 0x4c05: 0x0001, 0x4c06: 0x0001, 0x4c07: 0x0001, 0x4c08: 0x0001, 0x4c09: 0x0001, 0x4c0a: 0x0001, 0x4c0b: 0x0001, 0x4c0c: 0x0001, 0x4c0d: 0x0001, 0x4c0e: 0x0001, 0x4c0f: 0x0001, 0x4c10: 0x0001, 0x4c11: 0x0001, 0x4c12: 0x0001, 0x4c13: 0x0001, 0x4c14: 0x0001, 0x4c15: 0x0001, 0x4c16: 0x0001, 0x4c17: 0x0001, 0x4c18: 0x0001, 0x4c19: 0x0001, 0x4c1a: 0x0001, 0x4c1b: 0x0001, 0x4c1c: 0x0001, 0x4c1d: 0x0001, 0x4c1e: 0x0001, 0x4c1f: 0x0001, 0x4c20: 0x0001, 0x4c21: 0x0001, 0x4c22: 0x0001, 0x4c23: 0x0001, 0x4c24: 0x0001, 0x4c25: 0x0001, 0x4c28: 0x0001, 0x4c29: 0x0001, 0x4c2a: 0x0001, 0x4c2b: 0x0001, 0x4c2c: 0x0001, 0x4c2d: 0x0001, 0x4c2e: 0x0001, 0x4c2f: 0x0001, 0x4c30: 0x0001, 0x4c31: 0x0001, 0x4c32: 0x0001, 0x4c33: 0x0001, 0x4c34: 0x0001, 0x4c35: 0x0001, 0x4c36: 0x0001, 0x4c37: 0x0001, 0x4c38: 0x0001, 0x4c39: 0x0001, 0x4c3a: 0x0001, 0x4c3b: 0x0001, 0x4c3c: 0x0001, 0x4c3d: 0x0001, 0x4c3e: 0x0001, 0x4c3f: 0x0001, // Block 0x131, offset 0x4c40 0x4c40: 0x0001, 0x4c42: 0x0001, 0x4c43: 0x0001, 0x4c44: 0x0001, 0x4c45: 0x0001, 0x4c46: 0x0001, 0x4c47: 0x0001, 0x4c48: 0x0001, 0x4c49: 0x0001, 0x4c4a: 0x0001, 0x4c4b: 0x0001, 0x4c4c: 0x0001, 0x4c4d: 0x0001, 0x4c4e: 0x0001, 0x4c4f: 0x0001, 0x4c50: 0x0001, 0x4c51: 0x0001, 0x4c52: 0x0001, 0x4c53: 0x0001, 0x4c54: 0x0001, 0x4c55: 0x0001, 0x4c56: 0x0001, 0x4c57: 0x0001, 0x4c58: 0x0001, 0x4c59: 0x0001, 0x4c5a: 0x0001, 0x4c5c: 0x0001, 0x4c5d: 0x0001, 0x4c5e: 0x0001, 0x4c5f: 0x0001, 0x4c60: 0x0001, 0x4c61: 0x0001, 0x4c62: 0x0001, 0x4c63: 0x0001, 0x4c64: 0x0001, 0x4c65: 0x0001, 0x4c66: 0x0001, 0x4c67: 0x0001, 0x4c68: 0x0001, 0x4c69: 0x0001, 0x4c6a: 0x0001, 0x4c6b: 0x0001, 0x4c6c: 0x0001, 0x4c6d: 0x0001, 0x4c6e: 0x0001, 0x4c6f: 0x0001, 0x4c70: 0x0001, 0x4c71: 0x0001, 0x4c72: 0x0001, 0x4c73: 0x0001, 0x4c74: 0x0001, 0x4c75: 0x0001, 0x4c76: 0x0001, 0x4c77: 0x0001, 0x4c78: 0x0001, 0x4c79: 0x0001, 0x4c7a: 0x0001, 0x4c7c: 0x0001, 0x4c7d: 0x0001, 0x4c7e: 0x0001, 0x4c7f: 0x0001, // Block 0x132, offset 0x4c80 0x4c80: 0x0001, 0x4c81: 0x0001, 0x4c82: 0x0001, 0x4c83: 0x0001, 0x4c84: 0x0001, 0x4c85: 0x0001, 0x4c86: 0x0001, 0x4c87: 0x0001, 0x4c88: 0x0001, 0x4c89: 0x0001, 0x4c8a: 0x0001, 0x4c8b: 0x0001, 0x4c8c: 0x0001, 0x4c8d: 0x0001, 0x4c8e: 0x0001, 0x4c8f: 0x0001, 0x4c90: 0x0001, 0x4c91: 0x0001, 0x4c92: 0x0001, 0x4c93: 0x0001, 0x4c94: 0x0001, 0x4c96: 0x0001, 0x4c97: 0x0001, 0x4c98: 0x0001, 0x4c99: 0x0001, 0x4c9a: 0x0001, 0x4c9b: 0x0001, 0x4c9c: 0x0001, 0x4c9d: 0x0001, 0x4c9e: 0x0001, 0x4c9f: 0x0001, 0x4ca0: 0x0001, 0x4ca1: 0x0001, 0x4ca2: 0x0001, 0x4ca3: 0x0001, 0x4ca4: 0x0001, 0x4ca5: 0x0001, 0x4ca6: 0x0001, 0x4ca7: 0x0001, 0x4ca8: 0x0001, 0x4ca9: 0x0001, 0x4caa: 0x0001, 0x4cab: 0x0001, 0x4cac: 0x0001, 0x4cad: 0x0001, 0x4cae: 0x0001, 0x4caf: 0x0001, 0x4cb0: 0x0001, 0x4cb1: 0x0001, 0x4cb2: 0x0001, 0x4cb3: 0x0001, 0x4cb4: 0x0001, 0x4cb6: 0x0001, 0x4cb7: 0x0001, 0x4cb8: 0x0001, 0x4cb9: 0x0001, 0x4cba: 0x0001, 0x4cbb: 0x0001, 0x4cbc: 0x0001, 0x4cbd: 0x0001, 0x4cbe: 0x0001, 0x4cbf: 0x0001, // Block 0x133, offset 0x4cc0 0x4cc0: 0x0001, 0x4cc1: 0x0001, 0x4cc2: 0x0001, 0x4cc3: 0x0001, 0x4cc4: 0x0001, 0x4cc5: 0x0001, 0x4cc6: 0x0001, 0x4cc7: 0x0001, 0x4cc8: 0x0001, 0x4cc9: 0x0001, 0x4cca: 0x0001, 0x4ccb: 0x0001, 0x4ccc: 0x0001, 0x4ccd: 0x0001, 0x4cce: 0x0001, 0x4cd0: 0x0001, 0x4cd1: 0x0001, 0x4cd2: 0x0001, 0x4cd3: 0x0001, 0x4cd4: 0x0001, 0x4cd5: 0x0001, 0x4cd6: 0x0001, 0x4cd7: 0x0001, 0x4cd8: 0x0001, 0x4cd9: 0x0001, 0x4cda: 0x0001, 0x4cdb: 0x0001, 0x4cdc: 0x0001, 0x4cdd: 0x0001, 0x4cde: 0x0001, 0x4cdf: 0x0001, 0x4ce0: 0x0001, 0x4ce1: 0x0001, 0x4ce2: 0x0001, 0x4ce3: 0x0001, 0x4ce4: 0x0001, 0x4ce5: 0x0001, 0x4ce6: 0x0001, 0x4ce7: 0x0001, 0x4ce8: 0x0001, 0x4ce9: 0x0001, 0x4cea: 0x0001, 0x4ceb: 0x0001, 0x4cec: 0x0001, 0x4ced: 0x0001, 0x4cee: 0x0001, 0x4cf0: 0x0001, 0x4cf1: 0x0001, 0x4cf2: 0x0001, 0x4cf3: 0x0001, 0x4cf4: 0x0001, 0x4cf5: 0x0001, 0x4cf6: 0x0001, 0x4cf7: 0x0001, 0x4cf8: 0x0001, 0x4cf9: 0x0001, 0x4cfa: 0x0001, 0x4cfb: 0x0001, 0x4cfc: 0x0001, 0x4cfd: 0x0001, 0x4cfe: 0x0001, 0x4cff: 0x0001, // Block 0x134, offset 0x4d00 0x4d00: 0x0001, 0x4d01: 0x0001, 0x4d02: 0x0001, 0x4d03: 0x0001, 0x4d04: 0x0001, 0x4d05: 0x0001, 0x4d06: 0x0001, 0x4d07: 0x0001, 0x4d08: 0x0001, 0x4d0a: 0x0001, 0x4d0b: 0x0001, 0x4d0c: 0x0001, 0x4d0d: 0x0001, 0x4d0e: 0x0001, 0x4d0f: 0x0001, 0x4d10: 0x0001, 0x4d11: 0x0001, 0x4d12: 0x0001, 0x4d13: 0x0001, 0x4d14: 0x0001, 0x4d15: 0x0001, 0x4d16: 0x0001, 0x4d17: 0x0001, 0x4d18: 0x0001, 0x4d19: 0x0001, 0x4d1a: 0x0001, 0x4d1b: 0x0001, 0x4d1c: 0x0001, 0x4d1d: 0x0001, 0x4d1e: 0x0001, 0x4d1f: 0x0001, 0x4d20: 0x0001, 0x4d21: 0x0001, 0x4d22: 0x0001, 0x4d23: 0x0001, 0x4d24: 0x0001, 0x4d25: 0x0001, 0x4d26: 0x0001, 0x4d27: 0x0001, 0x4d28: 0x0001, 0x4d2a: 0x0001, 0x4d2b: 0x0001, 0x4d2c: 0x0001, 0x4d2d: 0x0001, 0x4d2e: 0x0001, 0x4d2f: 0x0001, 0x4d30: 0x0001, 0x4d31: 0x0001, 0x4d32: 0x0001, 0x4d33: 0x0001, 0x4d34: 0x0001, 0x4d35: 0x0001, 0x4d36: 0x0001, 0x4d37: 0x0001, 0x4d38: 0x0001, 0x4d39: 0x0001, 0x4d3a: 0x0001, 0x4d3b: 0x0001, 0x4d3c: 0x0001, 0x4d3d: 0x0001, 0x4d3e: 0x0001, 0x4d3f: 0x0001, // Block 0x135, offset 0x4d40 0x4d40: 0x0001, 0x4d41: 0x0001, 0x4d42: 0x0001, 0x4d44: 0x0001, 0x4d45: 0x0001, 0x4d46: 0x0001, 0x4d47: 0x0001, 0x4d48: 0x0001, 0x4d49: 0x0001, 0x4d4a: 0x0001, 0x4d4b: 0x0001, 0x4d4e: 0x4000, 0x4d4f: 0x4000, 0x4d50: 0x4000, 0x4d51: 0x4000, 0x4d52: 0x4000, 0x4d53: 0x4000, 0x4d54: 0x4000, 0x4d55: 0x4000, 0x4d56: 0x4000, 0x4d57: 0x4000, 0x4d58: 0x4000, 0x4d59: 0x4000, 0x4d5a: 0x4000, 0x4d5b: 0x4000, 0x4d5c: 0x4000, 0x4d5d: 0x4000, 0x4d5e: 0x4000, 0x4d5f: 0x4000, 0x4d60: 0x4000, 0x4d61: 0x4000, 0x4d62: 0x4000, 0x4d63: 0x4000, 0x4d64: 0x4000, 0x4d65: 0x4000, 0x4d66: 0x4000, 0x4d67: 0x4000, 0x4d68: 0x4000, 0x4d69: 0x4000, 0x4d6a: 0x4000, 0x4d6b: 0x4000, 0x4d6c: 0x4000, 0x4d6d: 0x4000, 0x4d6e: 0x4000, 0x4d6f: 0x4000, 0x4d70: 0x4000, 0x4d71: 0x4000, 0x4d72: 0x4000, 0x4d73: 0x4000, 0x4d74: 0x4000, 0x4d75: 0x4000, 0x4d76: 0x4000, 0x4d77: 0x4000, 0x4d78: 0x4000, 0x4d79: 0x4000, 0x4d7a: 0x4000, 0x4d7b: 0x4000, 0x4d7c: 0x4000, 0x4d7d: 0x4000, 0x4d7e: 0x4000, 0x4d7f: 0x4000, // Block 0x136, offset 0x4d80 0x4d80: 0x0008, 0x4d81: 0x0008, 0x4d82: 0x0008, 0x4d83: 0x0008, 0x4d84: 0x0008, 0x4d85: 0x0008, 0x4d86: 0x0008, 0x4d87: 0x0008, 0x4d88: 0x0008, 0x4d89: 0x0008, 0x4d8a: 0x0008, 0x4d8b: 0x0008, 0x4d8c: 0x0008, 0x4d8d: 0x0008, 0x4d8e: 0x0008, 0x4d8f: 0x0008, 0x4d90: 0x0008, 0x4d91: 0x0008, 0x4d92: 0x0008, 0x4d93: 0x0008, 0x4d94: 0x0008, 0x4d95: 0x0008, 0x4d96: 0x0008, 0x4d97: 0x0008, 0x4d98: 0x0008, 0x4d99: 0x0008, 0x4d9a: 0x0008, 0x4d9b: 0x0008, 0x4d9c: 0x0008, 0x4d9d: 0x0008, 0x4d9e: 0x0008, 0x4d9f: 0x0008, 0x4da0: 0x0008, 0x4da1: 0x0008, 0x4da2: 0x0008, 0x4da3: 0x0008, 0x4da4: 0x0008, 0x4da5: 0x0008, 0x4da6: 0x0008, 0x4da7: 0x0008, 0x4da8: 0x0008, 0x4da9: 0x0008, 0x4daa: 0x0008, 0x4dab: 0x0008, 0x4dac: 0x0008, 0x4dad: 0x0008, 0x4dae: 0x0008, 0x4daf: 0x0008, 0x4db0: 0x0008, 0x4db1: 0x0008, 0x4db2: 0x0008, 0x4db3: 0x0008, 0x4db4: 0x0008, 0x4db5: 0x0008, 0x4db6: 0x0008, 0x4dbb: 0x0008, 0x4dbc: 0x0008, 0x4dbd: 0x0008, 0x4dbe: 0x0008, 0x4dbf: 0x0008, // Block 0x137, offset 0x4dc0 0x4dc0: 0x0008, 0x4dc1: 0x0008, 0x4dc2: 0x0008, 0x4dc3: 0x0008, 0x4dc4: 0x0008, 0x4dc5: 0x0008, 0x4dc6: 0x0008, 0x4dc7: 0x0008, 0x4dc8: 0x0008, 0x4dc9: 0x0008, 0x4dca: 0x0008, 0x4dcb: 0x0008, 0x4dcc: 0x0008, 0x4dcd: 0x0008, 0x4dce: 0x0008, 0x4dcf: 0x0008, 0x4dd0: 0x0008, 0x4dd1: 0x0008, 0x4dd2: 0x0008, 0x4dd3: 0x0008, 0x4dd4: 0x0008, 0x4dd5: 0x0008, 0x4dd6: 0x0008, 0x4dd7: 0x0008, 0x4dd8: 0x0008, 0x4dd9: 0x0008, 0x4dda: 0x0008, 0x4ddb: 0x0008, 0x4ddc: 0x0008, 0x4ddd: 0x0008, 0x4dde: 0x0008, 0x4ddf: 0x0008, 0x4de0: 0x0008, 0x4de1: 0x0008, 0x4de2: 0x0008, 0x4de3: 0x0008, 0x4de4: 0x0008, 0x4de5: 0x0008, 0x4de6: 0x0008, 0x4de7: 0x0008, 0x4de8: 0x0008, 0x4de9: 0x0008, 0x4dea: 0x0008, 0x4deb: 0x0008, 0x4dec: 0x0008, 0x4df5: 0x0008, // Block 0x138, offset 0x4e00 0x4e04: 0x0008, 0x4e1b: 0x0008, 0x4e1c: 0x0008, 0x4e1d: 0x0008, 0x4e1e: 0x0008, 0x4e1f: 0x0008, 0x4e21: 0x0008, 0x4e22: 0x0008, 0x4e23: 0x0008, 0x4e24: 0x0008, 0x4e25: 0x0008, 0x4e26: 0x0008, 0x4e27: 0x0008, 0x4e28: 0x0008, 0x4e29: 0x0008, 0x4e2a: 0x0008, 0x4e2b: 0x0008, 0x4e2c: 0x0008, 0x4e2d: 0x0008, 0x4e2e: 0x0008, 0x4e2f: 0x0008, // Block 0x139, offset 0x4e40 0x4e40: 0x0001, 0x4e41: 0x0001, 0x4e42: 0x0001, 0x4e43: 0x0001, 0x4e44: 0x0001, 0x4e45: 0x0001, 0x4e46: 0x0001, 0x4e47: 0x0001, 0x4e48: 0x0001, 0x4e49: 0x0001, 0x4e4a: 0x0001, 0x4e4b: 0x0001, 0x4e4c: 0x0001, 0x4e4d: 0x0001, 0x4e4e: 0x0001, 0x4e4f: 0x0001, 0x4e50: 0x0001, 0x4e51: 0x0001, 0x4e52: 0x0001, 0x4e53: 0x0001, 0x4e54: 0x0001, 0x4e55: 0x0001, 0x4e56: 0x0001, 0x4e57: 0x0001, 0x4e58: 0x0001, 0x4e59: 0x0001, 0x4e5a: 0x0001, 0x4e5b: 0x0001, 0x4e5c: 0x0001, 0x4e5d: 0x0001, 0x4e5e: 0x0001, 0x4e65: 0x0001, 0x4e66: 0x0001, 0x4e67: 0x0001, 0x4e68: 0x0001, 0x4e69: 0x0001, 0x4e6a: 0x0001, // Block 0x13a, offset 0x4e80 0x4e80: 0x0008, 0x4e81: 0x0008, 0x4e82: 0x0008, 0x4e83: 0x0008, 0x4e84: 0x0008, 0x4e85: 0x0008, 0x4e86: 0x0008, 0x4e88: 0x0008, 0x4e89: 0x0008, 0x4e8a: 0x0008, 0x4e8b: 0x0008, 0x4e8c: 0x0008, 0x4e8d: 0x0008, 0x4e8e: 0x0008, 0x4e8f: 0x0008, 0x4e90: 0x0008, 0x4e91: 0x0008, 0x4e92: 0x0008, 0x4e93: 0x0008, 0x4e94: 0x0008, 0x4e95: 0x0008, 0x4e96: 0x0008, 0x4e97: 0x0008, 0x4e98: 0x0008, 0x4e9b: 0x0008, 0x4e9c: 0x0008, 0x4e9d: 0x0008, 0x4e9e: 0x0008, 0x4e9f: 0x0008, 0x4ea0: 0x0008, 0x4ea1: 0x0008, 0x4ea3: 0x0008, 0x4ea4: 0x0008, 0x4ea6: 0x0008, 0x4ea7: 0x0008, 0x4ea8: 0x0008, 0x4ea9: 0x0008, 0x4eaa: 0x0008, 0x4eb0: 0x0001, 0x4eb1: 0x0001, 0x4eb2: 0x0001, 0x4eb3: 0x0001, 0x4eb4: 0x0001, 0x4eb5: 0x0001, 0x4eb6: 0x0001, 0x4eb7: 0x0001, 0x4eb8: 0x0001, 0x4eb9: 0x0001, 0x4eba: 0x0001, 0x4ebb: 0x0001, 0x4ebc: 0x0001, 0x4ebd: 0x0001, 0x4ebe: 0x0001, 0x4ebf: 0x0001, // Block 0x13b, offset 0x4ec0 0x4ec0: 0x0001, 0x4ec1: 0x0001, 0x4ec2: 0x0001, 0x4ec3: 0x0001, 0x4ec4: 0x0001, 0x4ec5: 0x0001, 0x4ec6: 0x0001, 0x4ec7: 0x0001, 0x4ec8: 0x0001, 0x4ec9: 0x0001, 0x4eca: 0x0001, 0x4ecb: 0x0001, 0x4ecc: 0x0001, 0x4ecd: 0x0001, 0x4ece: 0x0001, 0x4ecf: 0x0001, 0x4ed0: 0x0001, 0x4ed1: 0x0001, 0x4ed2: 0x0001, 0x4ed3: 0x0001, 0x4ed4: 0x0001, 0x4ed5: 0x0001, 0x4ed6: 0x0001, 0x4ed7: 0x0001, 0x4ed8: 0x0001, 0x4ed9: 0x0001, 0x4eda: 0x0001, 0x4edb: 0x0001, 0x4edc: 0x0001, 0x4edd: 0x0001, 0x4ede: 0x0001, 0x4edf: 0x0001, 0x4ee0: 0x0001, 0x4ee1: 0x0001, 0x4ee2: 0x0001, 0x4ee3: 0x0001, 0x4ee4: 0x0001, 0x4ee5: 0x0001, 0x4ee6: 0x0001, 0x4ee7: 0x0001, 0x4ee8: 0x0001, 0x4ee9: 0x0001, 0x4eea: 0x0001, 0x4eeb: 0x0001, 0x4eec: 0x0001, 0x4eed: 0x0001, // Block 0x13c, offset 0x4f00 0x4f0f: 0x0008, // Block 0x13d, offset 0x4f40 0x4f40: 0x0001, 0x4f41: 0x0001, 0x4f42: 0x0001, 0x4f43: 0x0001, 0x4f44: 0x0001, 0x4f45: 0x0001, 0x4f46: 0x0001, 0x4f47: 0x0001, 0x4f48: 0x0001, 0x4f49: 0x0001, 0x4f4a: 0x0001, 0x4f4b: 0x0001, 0x4f4c: 0x0001, 0x4f4d: 0x0001, 0x4f4e: 0x0001, 0x4f4f: 0x0001, 0x4f50: 0x0001, 0x4f51: 0x0001, 0x4f52: 0x0001, 0x4f53: 0x0001, 0x4f54: 0x0001, 0x4f55: 0x0001, 0x4f56: 0x0001, 0x4f57: 0x0001, 0x4f58: 0x0001, 0x4f59: 0x0001, 0x4f5a: 0x0001, 0x4f5b: 0x0001, 0x4f5c: 0x0001, 0x4f5d: 0x0001, 0x4f5e: 0x0001, 0x4f5f: 0x0001, 0x4f60: 0x0001, 0x4f61: 0x0001, 0x4f62: 0x0001, 0x4f63: 0x0001, 0x4f64: 0x0001, 0x4f65: 0x0001, 0x4f66: 0x0001, 0x4f67: 0x0001, 0x4f68: 0x0001, 0x4f69: 0x0001, 0x4f6a: 0x0001, 0x4f6b: 0x0001, 0x4f6c: 0x0001, 0x4f70: 0x0008, 0x4f71: 0x0008, 0x4f72: 0x0008, 0x4f73: 0x0008, 0x4f74: 0x0008, 0x4f75: 0x0008, 0x4f76: 0x0008, 0x4f77: 0x0001, 0x4f78: 0x0001, 0x4f79: 0x0001, 0x4f7a: 0x0001, 0x4f7b: 0x0001, 0x4f7c: 0x0001, 0x4f7d: 0x0001, // Block 0x13e, offset 0x4f80 0x4f80: 0x4000, 0x4f81: 0x4000, 0x4f82: 0x4000, 0x4f83: 0x4000, 0x4f84: 0x4000, 0x4f85: 0x4000, 0x4f86: 0x4000, 0x4f87: 0x4000, 0x4f88: 0x4000, 0x4f89: 0x4000, 0x4f8e: 0x0001, // Block 0x13f, offset 0x4fc0 0x4fd0: 0x0001, 0x4fd1: 0x0001, 0x4fd2: 0x0001, 0x4fd3: 0x0001, 0x4fd4: 0x0001, 0x4fd5: 0x0001, 0x4fd6: 0x0001, 0x4fd7: 0x0001, 0x4fd8: 0x0001, 0x4fd9: 0x0001, 0x4fda: 0x0001, 0x4fdb: 0x0001, 0x4fdc: 0x0001, 0x4fdd: 0x0001, 0x4fde: 0x0001, 0x4fdf: 0x0001, 0x4fe0: 0x0001, 0x4fe1: 0x0001, 0x4fe2: 0x0001, 0x4fe3: 0x0001, 0x4fe4: 0x0001, 0x4fe5: 0x0001, 0x4fe6: 0x0001, 0x4fe7: 0x0001, 0x4fe8: 0x0001, 0x4fe9: 0x0001, 0x4fea: 0x0001, 0x4feb: 0x0001, 0x4fec: 0x0001, 0x4fed: 0x0001, 0x4fee: 0x0008, // Block 0x140, offset 0x5000 0x5000: 0x0001, 0x5001: 0x0001, 0x5002: 0x0001, 0x5003: 0x0001, 0x5004: 0x0001, 0x5005: 0x0001, 0x5006: 0x0001, 0x5007: 0x0001, 0x5008: 0x0001, 0x5009: 0x0001, 0x500a: 0x0001, 0x500b: 0x0001, 0x500c: 0x0001, 0x500d: 0x0001, 0x500e: 0x0001, 0x500f: 0x0001, 0x5010: 0x0001, 0x5011: 0x0001, 0x5012: 0x0001, 0x5013: 0x0001, 0x5014: 0x0001, 0x5015: 0x0001, 0x5016: 0x0001, 0x5017: 0x0001, 0x5018: 0x0001, 0x5019: 0x0001, 0x501a: 0x0001, 0x501b: 0x0001, 0x501c: 0x0001, 0x501d: 0x0001, 0x501e: 0x0001, 0x501f: 0x0001, 0x5020: 0x0001, 0x5021: 0x0001, 0x5022: 0x0001, 0x5023: 0x0001, 0x5024: 0x0001, 0x5025: 0x0001, 0x5026: 0x0001, 0x5027: 0x0001, 0x5028: 0x0001, 0x5029: 0x0001, 0x502a: 0x0001, 0x502b: 0x0001, 0x502c: 0x0008, 0x502d: 0x0008, 0x502e: 0x0008, 0x502f: 0x0008, 0x5030: 0x4000, 0x5031: 0x4000, 0x5032: 0x4000, 0x5033: 0x4000, 0x5034: 0x4000, 0x5035: 0x4000, 0x5036: 0x4000, 0x5037: 0x4000, 0x5038: 0x4000, 0x5039: 0x4000, // Block 0x141, offset 0x5040 0x5050: 0x0001, 0x5051: 0x0001, 0x5052: 0x0001, 0x5053: 0x0001, 0x5054: 0x0001, 0x5055: 0x0001, 0x5056: 0x0001, 0x5057: 0x0001, 0x5058: 0x0001, 0x5059: 0x0001, 0x505a: 0x0001, 0x505b: 0x0001, 0x505c: 0x0001, 0x505d: 0x0001, 0x505e: 0x0001, 0x505f: 0x0001, 0x5060: 0x0001, 0x5061: 0x0001, 0x5062: 0x0001, 0x5063: 0x0001, 0x5064: 0x0001, 0x5065: 0x0001, 0x5066: 0x0001, 0x5067: 0x0001, 0x5068: 0x0001, 0x5069: 0x0001, 0x506a: 0x0001, 0x506b: 0x0001, 0x506c: 0x0008, 0x506d: 0x0008, 0x506e: 0x0008, 0x506f: 0x0008, 0x5070: 0x4000, 0x5071: 0x4000, 0x5072: 0x4000, 0x5073: 0x4000, 0x5074: 0x4000, 0x5075: 0x4000, 0x5076: 0x4000, 0x5077: 0x4000, 0x5078: 0x4000, 0x5079: 0x4000, // Block 0x142, offset 0x5080 0x5090: 0x0001, 0x5091: 0x0001, 0x5092: 0x0001, 0x5093: 0x0001, 0x5094: 0x0001, 0x5095: 0x0001, 0x5096: 0x0001, 0x5097: 0x0001, 0x5098: 0x0001, 0x5099: 0x0001, 0x509a: 0x0001, 0x509b: 0x0001, 0x509c: 0x0001, 0x509d: 0x0001, 0x509e: 0x0001, 0x509f: 0x0001, 0x50a0: 0x0001, 0x50a1: 0x0001, 0x50a2: 0x0001, 0x50a3: 0x0001, 0x50a4: 0x0001, 0x50a5: 0x0001, 0x50a6: 0x0001, 0x50a7: 0x0001, 0x50a8: 0x0001, 0x50a9: 0x0001, 0x50aa: 0x0001, 0x50ab: 0x0001, 0x50ac: 0x0001, 0x50ad: 0x0001, 0x50ae: 0x0008, 0x50af: 0x0008, 0x50b0: 0x0001, 0x50b1: 0x4000, 0x50b2: 0x4000, 0x50b3: 0x4000, 0x50b4: 0x4000, 0x50b5: 0x4000, 0x50b6: 0x4000, 0x50b7: 0x4000, 0x50b8: 0x4000, 0x50b9: 0x4000, 0x50ba: 0x4000, // Block 0x143, offset 0x50c0 0x50c0: 0x0001, 0x50c1: 0x0001, 0x50c2: 0x0001, 0x50c3: 0x0001, 0x50c4: 0x0001, 0x50c5: 0x0001, 0x50c6: 0x0001, 0x50c7: 0x0001, 0x50c8: 0x0001, 0x50c9: 0x0001, 0x50ca: 0x0001, 0x50cb: 0x0001, 0x50cc: 0x0001, 0x50cd: 0x0001, 0x50ce: 0x0001, 0x50cf: 0x0001, 0x50d0: 0x0001, 0x50d1: 0x0001, 0x50d2: 0x0001, 0x50d3: 0x0001, 0x50d4: 0x0001, 0x50d5: 0x0001, 0x50d6: 0x0001, 0x50d7: 0x0001, 0x50d8: 0x0001, 0x50d9: 0x0001, 0x50da: 0x0001, 0x50db: 0x0001, 0x50dc: 0x0001, 0x50dd: 0x0001, 0x50de: 0x0001, 0x50e0: 0x0001, 0x50e1: 0x0001, 0x50e2: 0x0001, 0x50e3: 0x0008, 0x50e4: 0x0001, 0x50e5: 0x0001, 0x50e6: 0x0008, 0x50e7: 0x0001, 0x50e8: 0x0001, 0x50e9: 0x0001, 0x50ea: 0x0001, 0x50eb: 0x0001, 0x50ec: 0x0001, 0x50ed: 0x0001, 0x50ee: 0x0008, 0x50ef: 0x0008, 0x50f0: 0x0001, 0x50f1: 0x0001, 0x50f2: 0x0001, 0x50f3: 0x0001, 0x50f4: 0x0001, 0x50f5: 0x0008, 0x50fe: 0x0001, 0x50ff: 0x0001, // Block 0x144, offset 0x5100 0x5120: 0x0001, 0x5121: 0x0001, 0x5122: 0x0001, 0x5123: 0x0001, 0x5124: 0x0001, 0x5125: 0x0001, 0x5126: 0x0001, 0x5128: 0x0001, 0x5129: 0x0001, 0x512a: 0x0001, 0x512b: 0x0001, 0x512d: 0x0001, 0x512e: 0x0001, 0x5130: 0x0001, 0x5131: 0x0001, 0x5132: 0x0001, 0x5133: 0x0001, 0x5134: 0x0001, 0x5135: 0x0001, 0x5136: 0x0001, 0x5137: 0x0001, 0x5138: 0x0001, 0x5139: 0x0001, 0x513a: 0x0001, 0x513b: 0x0001, 0x513c: 0x0001, 0x513d: 0x0001, 0x513e: 0x0001, // Block 0x145, offset 0x5140 0x5140: 0x0001, 0x5141: 0x0001, 0x5142: 0x0001, 0x5143: 0x0001, 0x5144: 0x0001, 0x5150: 0x0008, 0x5151: 0x0008, 0x5152: 0x0008, 0x5153: 0x0008, 0x5154: 0x0008, 0x5155: 0x0008, 0x5156: 0x0008, // Block 0x146, offset 0x5180 0x5180: 0x0001, 0x5181: 0x0001, 0x5182: 0x0001, 0x5183: 0x0001, 0x5184: 0x0008, 0x5185: 0x0008, 0x5186: 0x0008, 0x5187: 0x0008, 0x5188: 0x0008, 0x5189: 0x0008, 0x518a: 0x0008, 0x518b: 0x0001, 0x5190: 0x4000, 0x5191: 0x4000, 0x5192: 0x4000, 0x5193: 0x4000, 0x5194: 0x4000, 0x5195: 0x4000, 0x5196: 0x4000, 0x5197: 0x4000, 0x5198: 0x4000, 0x5199: 0x4000, // Block 0x147, offset 0x51c0 0x51c0: 0x0001, 0x51c1: 0x0001, 0x51c2: 0x0001, 0x51c3: 0x0001, 0x51c5: 0x0001, 0x51c6: 0x0001, 0x51c7: 0x0001, 0x51c8: 0x0001, 0x51c9: 0x0001, 0x51ca: 0x0001, 0x51cb: 0x0001, 0x51cc: 0x0001, 0x51cd: 0x0001, 0x51ce: 0x0001, 0x51cf: 0x0001, 0x51d0: 0x0001, 0x51d1: 0x0001, 0x51d2: 0x0001, 0x51d3: 0x0001, 0x51d4: 0x0001, 0x51d5: 0x0001, 0x51d6: 0x0001, 0x51d7: 0x0001, 0x51d8: 0x0001, 0x51d9: 0x0001, 0x51da: 0x0001, 0x51db: 0x0001, 0x51dc: 0x0001, 0x51dd: 0x0001, 0x51de: 0x0001, 0x51df: 0x0001, 0x51e1: 0x0001, 0x51e2: 0x0001, 0x51e4: 0x0001, 0x51e7: 0x0001, 0x51e9: 0x0001, 0x51ea: 0x0001, 0x51eb: 0x0001, 0x51ec: 0x0001, 0x51ed: 0x0001, 0x51ee: 0x0001, 0x51ef: 0x0001, 0x51f0: 0x0001, 0x51f1: 0x0001, 0x51f2: 0x0001, 0x51f4: 0x0001, 0x51f5: 0x0001, 0x51f6: 0x0001, 0x51f7: 0x0001, 0x51f9: 0x0001, 0x51fb: 0x0001, // Block 0x148, offset 0x5200 0x5202: 0x0001, 0x5207: 0x0001, 0x5209: 0x0001, 0x520b: 0x0001, 0x520d: 0x0001, 0x520e: 0x0001, 0x520f: 0x0001, 0x5211: 0x0001, 0x5212: 0x0001, 0x5214: 0x0001, 0x5217: 0x0001, 0x5219: 0x0001, 0x521b: 0x0001, 0x521d: 0x0001, 0x521f: 0x0001, 0x5221: 0x0001, 0x5222: 0x0001, 0x5224: 0x0001, 0x5227: 0x0001, 0x5228: 0x0001, 0x5229: 0x0001, 0x522a: 0x0001, 0x522c: 0x0001, 0x522d: 0x0001, 0x522e: 0x0001, 0x522f: 0x0001, 0x5230: 0x0001, 0x5231: 0x0001, 0x5232: 0x0001, 0x5234: 0x0001, 0x5235: 0x0001, 0x5236: 0x0001, 0x5237: 0x0001, 0x5239: 0x0001, 0x523a: 0x0001, 0x523b: 0x0001, 0x523c: 0x0001, 0x523e: 0x0001, // Block 0x149, offset 0x5240 0x5240: 0x0001, 0x5241: 0x0001, 0x5242: 0x0001, 0x5243: 0x0001, 0x5244: 0x0001, 0x5245: 0x0001, 0x5246: 0x0001, 0x5247: 0x0001, 0x5248: 0x0001, 0x5249: 0x0001, 0x524b: 0x0001, 0x524c: 0x0001, 0x524d: 0x0001, 0x524e: 0x0001, 0x524f: 0x0001, 0x5250: 0x0001, 0x5251: 0x0001, 0x5252: 0x0001, 0x5253: 0x0001, 0x5254: 0x0001, 0x5255: 0x0001, 0x5256: 0x0001, 0x5257: 0x0001, 0x5258: 0x0001, 0x5259: 0x0001, 0x525a: 0x0001, 0x525b: 0x0001, 0x5261: 0x0001, 0x5262: 0x0001, 0x5263: 0x0001, 0x5265: 0x0001, 0x5266: 0x0001, 0x5267: 0x0001, 0x5268: 0x0001, 0x5269: 0x0001, 0x526b: 0x0001, 0x526c: 0x0001, 0x526d: 0x0001, 0x526e: 0x0001, 0x526f: 0x0001, 0x5270: 0x0001, 0x5271: 0x0001, 0x5272: 0x0001, 0x5273: 0x0001, 0x5274: 0x0001, 0x5275: 0x0001, 0x5276: 0x0001, 0x5277: 0x0001, 0x5278: 0x0001, 0x5279: 0x0001, 0x527a: 0x0001, 0x527b: 0x0001, // Block 0x14a, offset 0x5280 0x5284: 0x0020, 0x52ac: 0x0020, 0x52ad: 0x0020, 0x52ae: 0x0020, 0x52af: 0x0020, // Block 0x14b, offset 0x52c0 0x52d4: 0x0020, 0x52d5: 0x0020, 0x52d6: 0x0020, 0x52d7: 0x0020, 0x52d8: 0x0020, 0x52d9: 0x0020, 0x52da: 0x0020, 0x52db: 0x0020, 0x52dc: 0x0020, 0x52dd: 0x0020, 0x52de: 0x0020, 0x52df: 0x0020, 0x52ef: 0x0020, 0x52f0: 0x0020, // Block 0x14c, offset 0x5300 0x5300: 0x0020, 0x530f: 0x0020, 0x5310: 0x0020, 0x5336: 0x0020, 0x5337: 0x0020, 0x5338: 0x0020, 0x5339: 0x0020, 0x533a: 0x0020, 0x533b: 0x0020, 0x533c: 0x0020, 0x533d: 0x0020, 0x533e: 0x0020, 0x533f: 0x0020, // Block 0x14d, offset 0x5340 0x5370: 0x0001, 0x5371: 0x0001, 0x5372: 0x0001, 0x5373: 0x0001, 0x5374: 0x0001, 0x5375: 0x0001, 0x5376: 0x0001, 0x5377: 0x0001, 0x5378: 0x0001, 0x5379: 0x0001, 0x537a: 0x0001, 0x537b: 0x0001, 0x537c: 0x0001, 0x537d: 0x0001, 0x537e: 0x0001, 0x537f: 0x0001, // Block 0x14e, offset 0x5380 0x5380: 0x0001, 0x5381: 0x0001, 0x5382: 0x0001, 0x5383: 0x0001, 0x5384: 0x0001, 0x5385: 0x0001, 0x5386: 0x0001, 0x5387: 0x0001, 0x5388: 0x0001, 0x5389: 0x0001, 0x5390: 0x0001, 0x5391: 0x0001, 0x5392: 0x0001, 0x5393: 0x0001, 0x5394: 0x0001, 0x5395: 0x0001, 0x5396: 0x0001, 0x5397: 0x0001, 0x5398: 0x0001, 0x5399: 0x0001, 0x539a: 0x0001, 0x539b: 0x0001, 0x539c: 0x0001, 0x539d: 0x0001, 0x539e: 0x0001, 0x539f: 0x0001, 0x53a0: 0x0001, 0x53a1: 0x0001, 0x53a2: 0x0001, 0x53a3: 0x0001, 0x53a4: 0x0001, 0x53a5: 0x0001, 0x53a6: 0x0001, 0x53a7: 0x0001, 0x53a8: 0x0001, 0x53a9: 0x0001, 0x53b0: 0x0021, 0x53b1: 0x0021, 0x53b2: 0x0001, 0x53b3: 0x0001, 0x53b4: 0x0001, 0x53b5: 0x0001, 0x53b6: 0x0001, 0x53b7: 0x0001, 0x53b8: 0x0001, 0x53b9: 0x0001, 0x53ba: 0x0001, 0x53bb: 0x0001, 0x53bc: 0x0001, 0x53bd: 0x0001, 0x53be: 0x0021, 0x53bf: 0x0021, // Block 0x14f, offset 0x53c0 0x53c0: 0x0001, 0x53c1: 0x0001, 0x53c2: 0x0001, 0x53c3: 0x0001, 0x53c4: 0x0001, 0x53c5: 0x0001, 0x53c6: 0x0001, 0x53c7: 0x0001, 0x53c8: 0x0001, 0x53c9: 0x0001, 0x53ce: 0x0020, 0x53d1: 0x0020, 0x53d2: 0x0020, 0x53d3: 0x0020, 0x53d4: 0x0020, 0x53d5: 0x0020, 0x53d6: 0x0020, 0x53d7: 0x0020, 0x53d8: 0x0020, 0x53d9: 0x0020, 0x53da: 0x0020, 0x53ee: 0x0020, 0x53ef: 0x0020, 0x53f0: 0x0020, 0x53f1: 0x0020, 0x53f2: 0x0020, 0x53f3: 0x0020, 0x53f4: 0x0020, 0x53f5: 0x0020, 0x53f6: 0x0020, 0x53f7: 0x0020, 0x53f8: 0x0020, 0x53f9: 0x0020, 0x53fa: 0x0020, 0x53fb: 0x0020, 0x53fc: 0x0020, 0x53fd: 0x0020, 0x53fe: 0x0020, 0x53ff: 0x0020, // Block 0x150, offset 0x5400 0x5400: 0x0020, 0x5401: 0x0020, 0x5402: 0x0020, 0x5403: 0x0020, 0x5404: 0x0020, 0x5405: 0x0020, 0x5406: 0x0020, 0x5407: 0x0020, 0x5408: 0x0020, 0x5409: 0x0020, 0x540a: 0x0020, 0x540b: 0x0020, 0x540c: 0x0020, 0x540d: 0x0020, 0x540e: 0x0020, 0x540f: 0x0020, 0x5410: 0x0020, 0x5411: 0x0020, 0x5412: 0x0020, 0x5413: 0x0020, 0x5414: 0x0020, 0x5415: 0x0020, 0x5416: 0x0020, 0x5417: 0x0020, 0x5418: 0x0020, 0x5419: 0x0020, 0x541a: 0x0020, 0x541b: 0x0020, 0x541c: 0x0020, 0x541d: 0x0020, 0x541e: 0x0020, 0x541f: 0x0020, 0x5420: 0x0020, 0x5421: 0x0020, 0x5422: 0x0020, 0x5423: 0x0020, 0x5424: 0x0020, 0x5425: 0x0020, 0x5426: 0x8000, 0x5427: 0x8000, 0x5428: 0x8000, 0x5429: 0x8000, 0x542a: 0x8000, 0x542b: 0x8000, 0x542c: 0x8000, 0x542d: 0x8000, 0x542e: 0x8000, 0x542f: 0x8000, 0x5430: 0x8000, 0x5431: 0x8000, 0x5432: 0x8000, 0x5433: 0x8000, 0x5434: 0x8000, 0x5435: 0x8000, 0x5436: 0x8000, 0x5437: 0x8000, 0x5438: 0x8000, 0x5439: 0x8000, 0x543a: 0x8000, 0x543b: 0x8000, 0x543c: 0x8000, 0x543d: 0x8000, 0x543e: 0x8000, 0x543f: 0x8000, // Block 0x151, offset 0x5440 0x5441: 0x0020, 0x5442: 0x0020, 0x5443: 0x0020, 0x5444: 0x0020, 0x5445: 0x0020, 0x5446: 0x0020, 0x5447: 0x0020, 0x5448: 0x0020, 0x5449: 0x0020, 0x544a: 0x0020, 0x544b: 0x0020, 0x544c: 0x0020, 0x544d: 0x0020, 0x544e: 0x0020, 0x544f: 0x0020, 0x545a: 0x0020, 0x546f: 0x0020, 0x5472: 0x0020, 0x5473: 0x0020, 0x5474: 0x0020, 0x5475: 0x0020, 0x5476: 0x0020, 0x5477: 0x0020, 0x5478: 0x0020, 0x5479: 0x0020, 0x547a: 0x0020, 0x547c: 0x0020, 0x547d: 0x0020, 0x547e: 0x0020, 0x547f: 0x0020, // Block 0x152, offset 0x5480 0x5489: 0x0020, 0x548a: 0x0020, 0x548b: 0x0020, 0x548c: 0x0020, 0x548d: 0x0020, 0x548e: 0x0020, 0x548f: 0x0020, 0x5490: 0x0020, 0x5491: 0x0020, 0x5492: 0x0020, 0x5493: 0x0020, 0x5494: 0x0020, 0x5495: 0x0020, 0x5496: 0x0020, 0x5497: 0x0020, 0x5498: 0x0020, 0x5499: 0x0020, 0x549a: 0x0020, 0x549b: 0x0020, 0x549c: 0x0020, 0x549d: 0x0020, 0x549e: 0x0020, 0x549f: 0x0020, 0x54a6: 0x0020, 0x54a7: 0x0020, 0x54a8: 0x0020, 0x54a9: 0x0020, 0x54aa: 0x0020, 0x54ab: 0x0020, 0x54ac: 0x0020, 0x54ad: 0x0020, 0x54ae: 0x0020, 0x54af: 0x0020, 0x54b0: 0x0020, 0x54b1: 0x0020, 0x54b2: 0x0020, 0x54b3: 0x0020, 0x54b4: 0x0020, 0x54b5: 0x0020, 0x54b6: 0x0020, 0x54b7: 0x0020, 0x54b8: 0x0020, 0x54b9: 0x0020, 0x54ba: 0x0020, 0x54bb: 0x0020, 0x54bc: 0x0020, 0x54bd: 0x0020, 0x54be: 0x0020, 0x54bf: 0x0020, // Block 0x153, offset 0x54c0 0x54c0: 0x0020, 0x54c1: 0x0020, 0x54c2: 0x0020, 0x54c3: 0x0020, 0x54c4: 0x0020, 0x54c5: 0x0020, 0x54c6: 0x0020, 0x54c7: 0x0020, 0x54c8: 0x0020, 0x54c9: 0x0020, 0x54ca: 0x0020, 0x54cb: 0x0020, 0x54cc: 0x0020, 0x54cd: 0x0020, 0x54ce: 0x0020, 0x54cf: 0x0020, 0x54d0: 0x0020, 0x54d1: 0x0020, 0x54d2: 0x0020, 0x54d3: 0x0020, 0x54d4: 0x0020, 0x54d5: 0x0020, 0x54d6: 0x0020, 0x54d7: 0x0020, 0x54d8: 0x0020, 0x54d9: 0x0020, 0x54da: 0x0020, 0x54db: 0x0020, 0x54dc: 0x0020, 0x54dd: 0x0020, 0x54de: 0x0020, 0x54df: 0x0020, 0x54e0: 0x0020, 0x54e1: 0x0020, 0x54e2: 0x0020, 0x54e3: 0x0020, 0x54e4: 0x0020, 0x54e5: 0x0020, 0x54e6: 0x0020, 0x54e7: 0x0020, 0x54e8: 0x0020, 0x54e9: 0x0020, 0x54ea: 0x0020, 0x54eb: 0x0020, 0x54ec: 0x0020, 0x54ed: 0x0020, 0x54ee: 0x0020, 0x54ef: 0x0020, 0x54f0: 0x0020, 0x54f1: 0x0020, 0x54f2: 0x0020, 0x54f3: 0x0020, 0x54f4: 0x0020, 0x54f5: 0x0020, 0x54f6: 0x0020, 0x54f7: 0x0020, 0x54f8: 0x0020, 0x54f9: 0x0020, 0x54fa: 0x0020, 0x54fb: 0x0020, 0x54fc: 0x0020, 0x54fd: 0x0020, 0x54fe: 0x0020, 0x54ff: 0x0020, // Block 0x154, offset 0x5500 0x5500: 0x0020, 0x5501: 0x0020, 0x5502: 0x0020, 0x5503: 0x0020, 0x5504: 0x0020, 0x5505: 0x0020, 0x5506: 0x0020, 0x5507: 0x0020, 0x5508: 0x0020, 0x5509: 0x0020, 0x550a: 0x0020, 0x550b: 0x0020, 0x550c: 0x0020, 0x550d: 0x0020, 0x550e: 0x0020, 0x550f: 0x0020, 0x5510: 0x0020, 0x5511: 0x0020, 0x5512: 0x0020, 0x5513: 0x0020, 0x5514: 0x0020, 0x5515: 0x0020, 0x5516: 0x0020, 0x5517: 0x0020, 0x5518: 0x0020, 0x5519: 0x0020, 0x551a: 0x0020, 0x551b: 0x0020, 0x551c: 0x0020, 0x551d: 0x0020, 0x551e: 0x0020, 0x551f: 0x0020, 0x5520: 0x0020, 0x5521: 0x0020, 0x5524: 0x0020, 0x5525: 0x0020, 0x5526: 0x0020, 0x5527: 0x0020, 0x5528: 0x0020, 0x5529: 0x0020, 0x552a: 0x0020, 0x552b: 0x0020, 0x552c: 0x0020, 0x552d: 0x0020, 0x552e: 0x0020, 0x552f: 0x0020, 0x5530: 0x0020, 0x5531: 0x0020, 0x5532: 0x0020, 0x5533: 0x0020, 0x5534: 0x0020, 0x5535: 0x0020, 0x5536: 0x0020, 0x5537: 0x0020, 0x5538: 0x0020, 0x5539: 0x0020, 0x553a: 0x0020, 0x553b: 0x0020, 0x553c: 0x0020, 0x553d: 0x0020, 0x553e: 0x0020, 0x553f: 0x0020, // Block 0x155, offset 0x5540 0x5540: 0x0020, 0x5541: 0x0020, 0x5542: 0x0020, 0x5543: 0x0020, 0x5544: 0x0020, 0x5545: 0x0020, 0x5546: 0x0020, 0x5547: 0x0020, 0x5548: 0x0020, 0x5549: 0x0020, 0x554a: 0x0020, 0x554b: 0x0020, 0x554c: 0x0020, 0x554d: 0x0020, 0x554e: 0x0020, 0x554f: 0x0020, 0x5550: 0x0020, 0x5551: 0x0020, 0x5552: 0x0020, 0x5553: 0x0020, 0x5556: 0x0020, 0x5557: 0x0020, 0x5559: 0x0020, 0x555a: 0x0020, 0x555b: 0x0020, 0x555e: 0x0020, 0x555f: 0x0020, 0x5560: 0x0020, 0x5561: 0x0020, 0x5562: 0x0020, 0x5563: 0x0020, 0x5564: 0x0020, 0x5565: 0x0020, 0x5566: 0x0020, 0x5567: 0x0020, 0x5568: 0x0020, 0x5569: 0x0020, 0x556a: 0x0020, 0x556b: 0x0020, 0x556c: 0x0020, 0x556d: 0x0020, 0x556e: 0x0020, 0x556f: 0x0020, 0x5570: 0x0020, 0x5571: 0x0020, 0x5572: 0x0020, 0x5573: 0x0020, 0x5574: 0x0020, 0x5575: 0x0020, 0x5576: 0x0020, 0x5577: 0x0020, 0x5578: 0x0020, 0x5579: 0x0020, 0x557a: 0x0020, 0x557b: 0x0020, 0x557c: 0x0020, 0x557d: 0x0020, 0x557e: 0x0020, 0x557f: 0x0020, // Block 0x156, offset 0x5580 0x5580: 0x0020, 0x5581: 0x0020, 0x5582: 0x0020, 0x5583: 0x0020, 0x5584: 0x0020, 0x5585: 0x0020, 0x5586: 0x0020, 0x5587: 0x0020, 0x5588: 0x0020, 0x5589: 0x0020, 0x558a: 0x0020, 0x558b: 0x0020, 0x558c: 0x0020, 0x558d: 0x0020, 0x558e: 0x0020, 0x558f: 0x0020, 0x5590: 0x0020, 0x5591: 0x0020, 0x5592: 0x0020, 0x5593: 0x0020, 0x5594: 0x0020, 0x5595: 0x0020, 0x5596: 0x0020, 0x5597: 0x0020, 0x5598: 0x0020, 0x5599: 0x0020, 0x559a: 0x0020, 0x559b: 0x0020, 0x559c: 0x0020, 0x559d: 0x0020, 0x559e: 0x0020, 0x559f: 0x0020, 0x55a0: 0x0020, 0x55a1: 0x0020, 0x55a2: 0x0020, 0x55a3: 0x0020, 0x55a4: 0x0020, 0x55a5: 0x0020, 0x55a6: 0x0020, 0x55a7: 0x0020, 0x55a8: 0x0020, 0x55a9: 0x0020, 0x55aa: 0x0020, 0x55ab: 0x0020, 0x55ac: 0x0020, 0x55ad: 0x0020, 0x55ae: 0x0020, 0x55af: 0x0020, 0x55b0: 0x0020, 0x55b3: 0x0020, 0x55b4: 0x0020, 0x55b5: 0x0020, 0x55b7: 0x0020, 0x55b8: 0x0020, 0x55b9: 0x0020, 0x55ba: 0x0020, 0x55bb: 0x0008, 0x55bc: 0x0008, 0x55bd: 0x0008, 0x55be: 0x0008, 0x55bf: 0x0008, // Block 0x157, offset 0x55c0 0x55c0: 0x0020, 0x55c1: 0x0020, 0x55c2: 0x0020, 0x55c3: 0x0020, 0x55c4: 0x0020, 0x55c5: 0x0020, 0x55c6: 0x0020, 0x55c7: 0x0020, 0x55c8: 0x0020, 0x55c9: 0x0020, 0x55ca: 0x0020, 0x55cb: 0x0020, 0x55cc: 0x0020, 0x55cd: 0x0020, 0x55ce: 0x0020, 0x55cf: 0x0020, 0x55d0: 0x0020, 0x55d1: 0x0020, 0x55d2: 0x0020, 0x55d3: 0x0020, 0x55d4: 0x0020, 0x55d5: 0x0020, 0x55d6: 0x0020, 0x55d7: 0x0020, 0x55d8: 0x0020, 0x55d9: 0x0020, 0x55da: 0x0020, 0x55db: 0x0020, 0x55dc: 0x0020, 0x55dd: 0x0020, 0x55de: 0x0020, 0x55df: 0x0020, 0x55e0: 0x0020, 0x55e1: 0x0020, 0x55e2: 0x0020, 0x55e3: 0x0020, 0x55e4: 0x0020, 0x55e5: 0x0020, 0x55e6: 0x0020, 0x55e7: 0x0020, 0x55e8: 0x0020, 0x55e9: 0x0020, 0x55ea: 0x0020, 0x55eb: 0x0020, 0x55ec: 0x0020, 0x55ed: 0x0020, 0x55ee: 0x0020, 0x55ef: 0x0020, 0x55f0: 0x0020, 0x55f1: 0x0020, 0x55f2: 0x0020, 0x55f3: 0x0020, 0x55f4: 0x0020, 0x55f5: 0x0020, 0x55f6: 0x0020, 0x55f7: 0x0020, 0x55f8: 0x0020, 0x55f9: 0x0020, 0x55fa: 0x0020, 0x55fb: 0x0020, 0x55fc: 0x0020, 0x55fd: 0x0020, 0x55ff: 0x0020, // Block 0x158, offset 0x5600 0x5600: 0x0020, 0x5601: 0x0020, 0x5602: 0x0020, 0x5603: 0x0020, 0x5604: 0x0020, 0x5605: 0x0020, 0x5606: 0x0020, 0x5607: 0x0020, 0x5608: 0x0020, 0x5609: 0x0020, 0x560a: 0x0020, 0x560b: 0x0020, 0x560c: 0x0020, 0x560d: 0x0020, 0x560e: 0x0020, 0x560f: 0x0020, 0x5610: 0x0020, 0x5611: 0x0020, 0x5612: 0x0020, 0x5613: 0x0020, 0x5614: 0x0020, 0x5615: 0x0020, 0x5616: 0x0020, 0x5617: 0x0020, 0x5618: 0x0020, 0x5619: 0x0020, 0x561a: 0x0020, 0x561b: 0x0020, 0x561c: 0x0020, 0x561d: 0x0020, 0x561e: 0x0020, 0x561f: 0x0020, 0x5620: 0x0020, 0x5621: 0x0020, 0x5622: 0x0020, 0x5623: 0x0020, 0x5624: 0x0020, 0x5625: 0x0020, 0x5626: 0x0020, 0x5627: 0x0020, 0x5628: 0x0020, 0x5629: 0x0020, 0x562a: 0x0020, 0x562b: 0x0020, 0x562c: 0x0020, 0x562d: 0x0020, 0x562e: 0x0020, 0x562f: 0x0020, 0x5630: 0x0020, 0x5631: 0x0020, 0x5632: 0x0020, 0x5633: 0x0020, 0x5634: 0x0020, 0x5635: 0x0020, 0x5636: 0x0020, 0x5637: 0x0020, 0x5638: 0x0020, 0x5639: 0x0020, 0x563a: 0x0020, 0x563b: 0x0020, 0x563c: 0x0020, 0x563d: 0x0020, // Block 0x159, offset 0x5640 0x5649: 0x0020, 0x564a: 0x0020, 0x564b: 0x0020, 0x564c: 0x0020, 0x564d: 0x0020, 0x564e: 0x0020, 0x5650: 0x0020, 0x5651: 0x0020, 0x5652: 0x0020, 0x5653: 0x0020, 0x5654: 0x0020, 0x5655: 0x0020, 0x5656: 0x0020, 0x5657: 0x0020, 0x5658: 0x0020, 0x5659: 0x0020, 0x565a: 0x0020, 0x565b: 0x0020, 0x565c: 0x0020, 0x565d: 0x0020, 0x565e: 0x0020, 0x565f: 0x0020, 0x5660: 0x0020, 0x5661: 0x0020, 0x5662: 0x0020, 0x5663: 0x0020, 0x5664: 0x0020, 0x5665: 0x0020, 0x5666: 0x0020, 0x5667: 0x0020, 0x566f: 0x0020, 0x5670: 0x0020, 0x5673: 0x0020, 0x5674: 0x0020, 0x5675: 0x0020, 0x5676: 0x0020, 0x5677: 0x0020, 0x5678: 0x0020, 0x5679: 0x0020, 0x567a: 0x0020, // Block 0x15a, offset 0x5680 0x5687: 0x0020, 0x568a: 0x0020, 0x568b: 0x0020, 0x568c: 0x0020, 0x568d: 0x0020, 0x5690: 0x0020, 0x5695: 0x0020, 0x5696: 0x0020, 0x56a4: 0x0020, 0x56a5: 0x0020, 0x56a8: 0x0020, 0x56b1: 0x0020, 0x56b2: 0x0020, 0x56bc: 0x0020, // Block 0x15b, offset 0x56c0 0x56c2: 0x0020, 0x56c3: 0x0020, 0x56c4: 0x0020, 0x56d1: 0x0020, 0x56d2: 0x0020, 0x56d3: 0x0020, 0x56dc: 0x0020, 0x56dd: 0x0020, 0x56de: 0x0020, 0x56e1: 0x0020, 0x56e3: 0x0020, 0x56e8: 0x0020, 0x56ef: 0x0020, 0x56f3: 0x0020, 0x56fa: 0x0020, 0x56fb: 0x0020, 0x56fc: 0x0020, 0x56fd: 0x0020, 0x56fe: 0x0020, 0x56ff: 0x0020, // Block 0x15c, offset 0x5700 0x5700: 0x0020, 0x5701: 0x0020, 0x5702: 0x0020, 0x5703: 0x0020, 0x5704: 0x0020, 0x5705: 0x0020, 0x5706: 0x0020, 0x5707: 0x0020, 0x5708: 0x0020, 0x5709: 0x0020, 0x570a: 0x0020, 0x570b: 0x0020, 0x570c: 0x0020, 0x570d: 0x0020, 0x570e: 0x0020, 0x570f: 0x0020, // Block 0x15d, offset 0x5740 0x5740: 0x0020, 0x5741: 0x0020, 0x5742: 0x0020, 0x5743: 0x0020, 0x5744: 0x0020, 0x5745: 0x0020, 0x574b: 0x0020, 0x574c: 0x0020, 0x574d: 0x0020, 0x574e: 0x0020, 0x574f: 0x0020, 0x5750: 0x0020, 0x5751: 0x0020, 0x5752: 0x0020, 0x5755: 0x0020, 0x5756: 0x0020, 0x5757: 0x0020, 0x5758: 0x0020, 0x5759: 0x0020, 0x575a: 0x0020, 0x575b: 0x0020, 0x575c: 0x0020, 0x575d: 0x0020, 0x575e: 0x0020, 0x575f: 0x0020, 0x5760: 0x0020, 0x5761: 0x0020, 0x5762: 0x0020, 0x5763: 0x0020, 0x5764: 0x0020, 0x5765: 0x0020, 0x5769: 0x0020, 0x576b: 0x0020, 0x576c: 0x0020, 0x576d: 0x0020, 0x576e: 0x0020, 0x576f: 0x0020, 0x5770: 0x0020, 0x5773: 0x0020, 0x5774: 0x0020, 0x5775: 0x0020, 0x5776: 0x0020, 0x5777: 0x0020, 0x5778: 0x0020, 0x5779: 0x0020, 0x577a: 0x0020, 0x577b: 0x0020, 0x577c: 0x0020, 0x577d: 0x0020, 0x577e: 0x0020, 0x577f: 0x0020, // Block 0x15e, offset 0x5780 0x579a: 0x0020, 0x579b: 0x0020, 0x579c: 0x0020, 0x579d: 0x0020, 0x579e: 0x0020, 0x579f: 0x0020, 0x57a0: 0x0020, 0x57a1: 0x0020, 0x57a2: 0x0020, 0x57a3: 0x0020, 0x57a4: 0x0020, 0x57a5: 0x0020, 0x57a6: 0x0020, 0x57a7: 0x0020, 0x57a8: 0x0020, 0x57a9: 0x0020, 0x57aa: 0x0020, 0x57ab: 0x0020, 0x57ac: 0x0020, 0x57ad: 0x0020, 0x57ae: 0x0020, 0x57af: 0x0020, 0x57b0: 0x0020, 0x57b1: 0x0020, 0x57b2: 0x0020, 0x57b3: 0x0020, 0x57b4: 0x0020, 0x57b5: 0x0020, 0x57b6: 0x0020, 0x57b7: 0x0020, 0x57b8: 0x0020, 0x57b9: 0x0020, 0x57ba: 0x0020, 0x57bb: 0x0020, 0x57bc: 0x0020, 0x57bd: 0x0020, 0x57be: 0x0020, 0x57bf: 0x0020, // Block 0x15f, offset 0x57c0 0x57cc: 0x0020, 0x57cd: 0x0020, 0x57ce: 0x0020, 0x57cf: 0x0020, // Block 0x160, offset 0x5800 0x5808: 0x0020, 0x5809: 0x0020, 0x580a: 0x0020, 0x580b: 0x0020, 0x580c: 0x0020, 0x580d: 0x0020, 0x580e: 0x0020, 0x580f: 0x0020, 0x581a: 0x0020, 0x581b: 0x0020, 0x581c: 0x0020, 0x581d: 0x0020, 0x581e: 0x0020, 0x581f: 0x0020, // Block 0x161, offset 0x5840 0x5848: 0x0020, 0x5849: 0x0020, 0x584a: 0x0020, 0x584b: 0x0020, 0x584c: 0x0020, 0x584d: 0x0020, 0x584e: 0x0020, 0x584f: 0x0020, 0x586e: 0x0020, 0x586f: 0x0020, 0x587c: 0x0020, 0x587d: 0x0020, 0x587e: 0x0020, 0x587f: 0x0020, // Block 0x162, offset 0x5880 0x5882: 0x0020, 0x5883: 0x0020, 0x5884: 0x0020, 0x5885: 0x0020, 0x5886: 0x0020, 0x5887: 0x0020, 0x5888: 0x0020, 0x5889: 0x0020, 0x588a: 0x0020, 0x588b: 0x0020, 0x588c: 0x0020, 0x588d: 0x0020, 0x588e: 0x0020, 0x588f: 0x0020, 0x5899: 0x0020, 0x589a: 0x0020, 0x589b: 0x0020, 0x589c: 0x0020, 0x589d: 0x0020, 0x589e: 0x0020, 0x589f: 0x0020, 0x58a0: 0x0020, 0x58a1: 0x0020, 0x58a2: 0x0020, 0x58a3: 0x0020, 0x58a4: 0x0020, 0x58a5: 0x0020, 0x58a6: 0x0020, 0x58a7: 0x0020, 0x58a8: 0x0020, 0x58a9: 0x0020, 0x58aa: 0x0020, 0x58ab: 0x0020, 0x58ac: 0x0020, 0x58ad: 0x0020, 0x58ae: 0x0020, 0x58af: 0x0020, 0x58b0: 0x0020, 0x58b1: 0x0020, 0x58b2: 0x0020, 0x58b3: 0x0020, 0x58b4: 0x0020, 0x58b5: 0x0020, 0x58b6: 0x0020, 0x58b7: 0x0020, 0x58b8: 0x0020, 0x58b9: 0x0020, 0x58ba: 0x0020, 0x58bb: 0x0020, 0x58bc: 0x0020, 0x58bd: 0x0020, 0x58be: 0x0020, 0x58bf: 0x0020, // Block 0x163, offset 0x58c0 0x58cc: 0x0020, 0x58cd: 0x0020, 0x58ce: 0x0020, 0x58cf: 0x0020, 0x58d0: 0x0020, 0x58d1: 0x0020, 0x58d2: 0x0020, 0x58d3: 0x0020, 0x58d4: 0x0020, 0x58d5: 0x0020, 0x58d6: 0x0020, 0x58d7: 0x0020, 0x58d8: 0x0020, 0x58d9: 0x0020, 0x58da: 0x0020, 0x58db: 0x0020, 0x58dc: 0x0020, 0x58dd: 0x0020, 0x58de: 0x0020, 0x58df: 0x0020, 0x58e0: 0x0020, 0x58e1: 0x0020, 0x58e2: 0x0020, 0x58e3: 0x0020, 0x58e4: 0x0020, 0x58e5: 0x0020, 0x58e6: 0x0020, 0x58e7: 0x0020, 0x58e8: 0x0020, 0x58e9: 0x0020, 0x58ea: 0x0020, 0x58eb: 0x0020, 0x58ec: 0x0020, 0x58ed: 0x0020, 0x58ee: 0x0020, 0x58ef: 0x0020, 0x58f0: 0x0020, 0x58f1: 0x0020, 0x58f2: 0x0020, 0x58f3: 0x0020, 0x58f4: 0x0020, 0x58f5: 0x0020, 0x58f6: 0x0020, 0x58f7: 0x0020, 0x58f8: 0x0020, 0x58f9: 0x0020, 0x58fa: 0x0020, 0x58fc: 0x0020, 0x58fd: 0x0020, 0x58fe: 0x0020, 0x58ff: 0x0020, // Block 0x164, offset 0x5900 0x5900: 0x0020, 0x5901: 0x0020, 0x5902: 0x0020, 0x5903: 0x0020, 0x5904: 0x0020, 0x5905: 0x0020, 0x5907: 0x0020, 0x5908: 0x0020, 0x5909: 0x0020, 0x590a: 0x0020, 0x590b: 0x0020, 0x590c: 0x0020, 0x590d: 0x0020, 0x590e: 0x0020, 0x590f: 0x0020, 0x5910: 0x0020, 0x5911: 0x0020, 0x5912: 0x0020, 0x5913: 0x0020, 0x5914: 0x0020, 0x5915: 0x0020, 0x5916: 0x0020, 0x5917: 0x0020, 0x5918: 0x0020, 0x5919: 0x0020, 0x591a: 0x0020, 0x591b: 0x0020, 0x591c: 0x0020, 0x591d: 0x0020, 0x591e: 0x0020, 0x591f: 0x0020, 0x5920: 0x0020, 0x5921: 0x0020, 0x5922: 0x0020, 0x5923: 0x0020, 0x5924: 0x0020, 0x5925: 0x0020, 0x5926: 0x0020, 0x5927: 0x0020, 0x5928: 0x0020, 0x5929: 0x0020, 0x592a: 0x0020, 0x592b: 0x0020, 0x592c: 0x0020, 0x592d: 0x0020, 0x592e: 0x0020, 0x592f: 0x0020, 0x5930: 0x0020, 0x5931: 0x0020, 0x5932: 0x0020, 0x5933: 0x0020, 0x5934: 0x0020, 0x5935: 0x0020, 0x5936: 0x0020, 0x5937: 0x0020, 0x5938: 0x0020, 0x5939: 0x0020, 0x593a: 0x0020, 0x593b: 0x0020, 0x593c: 0x0020, 0x593d: 0x0020, 0x593e: 0x0020, 0x593f: 0x0020, // Block 0x165, offset 0x5940 0x5958: 0x0020, 0x5959: 0x0020, 0x595a: 0x0020, 0x595b: 0x0020, 0x595c: 0x0020, 0x595d: 0x0020, 0x595e: 0x0020, 0x595f: 0x0020, 0x596e: 0x0020, 0x596f: 0x0020, 0x5970: 0x0020, 0x5971: 0x0020, 0x5972: 0x0020, 0x5973: 0x0020, 0x5974: 0x0020, 0x5975: 0x0020, 0x5976: 0x0020, 0x5977: 0x0020, 0x5978: 0x0020, 0x5979: 0x0020, 0x597a: 0x0020, 0x597b: 0x0020, 0x597c: 0x0020, 0x597d: 0x0020, 0x597e: 0x0020, 0x597f: 0x0020, // Block 0x166, offset 0x5980 0x5981: 0x0040, 0x59a0: 0x0008, 0x59a1: 0x0008, 0x59a2: 0x0008, 0x59a3: 0x0008, 0x59a4: 0x0008, 0x59a5: 0x0008, 0x59a6: 0x0008, 0x59a7: 0x0008, 0x59a8: 0x0008, 0x59a9: 0x0008, 0x59aa: 0x0008, 0x59ab: 0x0008, 0x59ac: 0x0008, 0x59ad: 0x0008, 0x59ae: 0x0008, 0x59af: 0x0008, 0x59b0: 0x0008, 0x59b1: 0x0008, 0x59b2: 0x0008, 0x59b3: 0x0008, 0x59b4: 0x0008, 0x59b5: 0x0008, 0x59b6: 0x0008, 0x59b7: 0x0008, 0x59b8: 0x0008, 0x59b9: 0x0008, 0x59ba: 0x0008, 0x59bb: 0x0008, 0x59bc: 0x0008, 0x59bd: 0x0008, 0x59be: 0x0008, 0x59bf: 0x0008, // Block 0x167, offset 0x59c0 0x59c0: 0x0008, 0x59c1: 0x0008, 0x59c2: 0x0008, 0x59c3: 0x0008, 0x59c4: 0x0008, 0x59c5: 0x0008, 0x59c6: 0x0008, 0x59c7: 0x0008, 0x59c8: 0x0008, 0x59c9: 0x0008, 0x59ca: 0x0008, 0x59cb: 0x0008, 0x59cc: 0x0008, 0x59cd: 0x0008, 0x59ce: 0x0008, 0x59cf: 0x0008, 0x59d0: 0x0008, 0x59d1: 0x0008, 0x59d2: 0x0008, 0x59d3: 0x0008, 0x59d4: 0x0008, 0x59d5: 0x0008, 0x59d6: 0x0008, 0x59d7: 0x0008, 0x59d8: 0x0008, 0x59d9: 0x0008, 0x59da: 0x0008, 0x59db: 0x0008, 0x59dc: 0x0008, 0x59dd: 0x0008, 0x59de: 0x0008, 0x59df: 0x0008, 0x59e0: 0x0008, 0x59e1: 0x0008, 0x59e2: 0x0008, 0x59e3: 0x0008, 0x59e4: 0x0008, 0x59e5: 0x0008, 0x59e6: 0x0008, 0x59e7: 0x0008, 0x59e8: 0x0008, 0x59e9: 0x0008, 0x59ea: 0x0008, 0x59eb: 0x0008, 0x59ec: 0x0008, 0x59ed: 0x0008, 0x59ee: 0x0008, 0x59ef: 0x0008, } // phrasesIndex: 27 blocks, 1728 entries, 3456 bytes // Block 0 is the zero block. var phrasesIndex = [1728]property{ // Block 0x0, offset 0x0 // Block 0x1, offset 0x40 // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc2: 0x01, 0xc3: 0x02, 0xc4: 0x03, 0xc5: 0x03, 0xc6: 0x03, 0xc7: 0x03, 0xc8: 0x03, 0xc9: 0x03, 0xca: 0x03, 0xcb: 0x04, 0xcc: 0x05, 0xcd: 0x06, 0xce: 0x07, 0xcf: 0x08, 0xd0: 0x03, 0xd1: 0x03, 0xd2: 0x09, 0xd3: 0x03, 0xd4: 0x0a, 0xd5: 0x0b, 0xd6: 0x0c, 0xd7: 0x0d, 0xd8: 0x0e, 0xd9: 0x0f, 0xda: 0x03, 0xdb: 0x10, 0xdc: 0x11, 0xdd: 0x12, 0xde: 0x13, 0xdf: 0x14, 0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xea: 0x06, 0xeb: 0x07, 0xec: 0x07, 0xed: 0x08, 0xef: 0x09, 0xf0: 0x16, 0xf3: 0x18, // Block 0x4, offset 0x100 0x120: 0x15, 0x121: 0x16, 0x122: 0x17, 0x123: 0x18, 0x124: 0x19, 0x125: 0x1a, 0x126: 0x1b, 0x127: 0x1c, 0x128: 0x1d, 0x129: 0x1e, 0x12a: 0x1f, 0x12b: 0x20, 0x12c: 0x21, 0x12d: 0x22, 0x12e: 0x23, 0x12f: 0x24, 0x130: 0x25, 0x131: 0x26, 0x132: 0x27, 0x133: 0x28, 0x134: 0x29, 0x135: 0x2a, 0x136: 0x2b, 0x137: 0x2c, 0x138: 0x2d, 0x139: 0x2e, 0x13a: 0x2f, 0x13b: 0x30, 0x13c: 0x31, 0x13d: 0x32, 0x13e: 0x33, 0x13f: 0x34, // Block 0x5, offset 0x140 0x140: 0x35, 0x141: 0x36, 0x142: 0x37, 0x143: 0x38, 0x144: 0x03, 0x145: 0x03, 0x146: 0x03, 0x147: 0x03, 0x148: 0x03, 0x149: 0x39, 0x14a: 0x3a, 0x14b: 0x3b, 0x14c: 0x3c, 0x14d: 0x3d, 0x14e: 0x3e, 0x14f: 0x3f, 0x150: 0x40, 0x151: 0x03, 0x152: 0x03, 0x153: 0x03, 0x154: 0x03, 0x155: 0x03, 0x156: 0x03, 0x157: 0x03, 0x158: 0x03, 0x159: 0x41, 0x15a: 0x42, 0x15b: 0x43, 0x15c: 0x44, 0x15d: 0x45, 0x15e: 0x46, 0x15f: 0x47, 0x160: 0x48, 0x161: 0x49, 0x162: 0x4a, 0x163: 0x4b, 0x164: 0x4c, 0x165: 0x4d, 0x167: 0x4e, 0x168: 0x4f, 0x169: 0x50, 0x16a: 0x51, 0x16b: 0x52, 0x16c: 0x53, 0x16d: 0x54, 0x16e: 0x55, 0x16f: 0x56, 0x170: 0x57, 0x171: 0x58, 0x172: 0x59, 0x173: 0x5a, 0x174: 0x03, 0x175: 0x03, 0x176: 0x03, 0x177: 0x05, 0x178: 0x03, 0x179: 0x03, 0x17a: 0x03, 0x17b: 0x03, 0x17c: 0x5b, 0x17d: 0x5c, 0x17e: 0x5d, 0x17f: 0x5e, // Block 0x6, offset 0x180 0x180: 0x5f, 0x181: 0x60, 0x182: 0x61, 0x183: 0x62, 0x184: 0x63, 0x185: 0x64, 0x186: 0x65, 0x18c: 0x66, 0x18f: 0x67, 0x192: 0x68, 0x193: 0x69, 0x196: 0x6a, 0x197: 0x6b, 0x198: 0x6c, 0x199: 0x6d, 0x19a: 0x6e, 0x19b: 0x6f, 0x19c: 0x70, 0x19d: 0x71, 0x19e: 0x72, 0x1a4: 0x73, 0x1ac: 0x74, 0x1ad: 0x75, 0x1b0: 0x03, 0x1b1: 0x03, 0x1b2: 0x03, 0x1b3: 0x76, 0x1b4: 0x77, 0x1b5: 0x78, 0x1b6: 0x79, 0x1b7: 0x7a, 0x1b8: 0x7b, // Block 0x7, offset 0x1c0 0x1c0: 0x7c, 0x1c2: 0x7d, 0x1c3: 0x7e, 0x1c4: 0x7f, 0x1c5: 0x03, 0x1c6: 0x80, 0x1c7: 0x81, 0x1ca: 0x82, 0x1cb: 0x83, 0x1cc: 0x84, 0x1cd: 0x85, // Block 0x8, offset 0x200 0x200: 0x03, 0x201: 0x03, 0x202: 0x03, 0x203: 0x03, 0x204: 0x03, 0x205: 0x03, 0x206: 0x03, 0x207: 0x03, 0x208: 0x03, 0x209: 0x03, 0x20a: 0x03, 0x20b: 0x03, 0x20c: 0x03, 0x20d: 0x03, 0x20e: 0x03, 0x20f: 0x03, 0x210: 0x03, 0x211: 0x03, 0x212: 0x86, 0x213: 0x87, 0x214: 0x03, 0x215: 0x03, 0x216: 0x03, 0x217: 0x03, 0x218: 0x88, 0x219: 0x89, 0x21a: 0x8a, 0x21b: 0x8b, 0x21c: 0x8c, 0x21d: 0x03, 0x21e: 0x03, 0x21f: 0x8d, 0x220: 0x8e, 0x221: 0x8f, 0x222: 0x90, 0x223: 0x91, 0x224: 0x92, 0x225: 0x93, 0x226: 0x94, 0x227: 0x95, 0x228: 0x96, 0x229: 0x97, 0x22a: 0x98, 0x22b: 0x99, 0x22c: 0x9a, 0x22d: 0x9b, 0x22e: 0x03, 0x22f: 0x9c, 0x230: 0x03, 0x231: 0x03, 0x232: 0x03, 0x233: 0x03, 0x234: 0x03, 0x235: 0x03, 0x236: 0x03, 0x237: 0x03, 0x238: 0x03, 0x239: 0x03, 0x23a: 0x03, 0x23b: 0x03, 0x23c: 0x03, 0x23d: 0x03, 0x23e: 0x03, 0x23f: 0x03, // Block 0x9, offset 0x240 0x240: 0x03, 0x241: 0x03, 0x242: 0x03, 0x243: 0x03, 0x244: 0x03, 0x245: 0x03, 0x246: 0x03, 0x247: 0x03, 0x248: 0x03, 0x249: 0x03, 0x24a: 0x03, 0x24b: 0x03, 0x24c: 0x03, 0x24d: 0x03, 0x24e: 0x03, 0x24f: 0x03, 0x250: 0x03, 0x251: 0x03, 0x252: 0x03, 0x253: 0x03, 0x254: 0x03, 0x255: 0x03, 0x256: 0x03, 0x257: 0x03, 0x258: 0x03, 0x259: 0x03, 0x25a: 0x03, 0x25b: 0x03, 0x25c: 0x03, 0x25d: 0x03, 0x25e: 0x03, 0x25f: 0x03, 0x260: 0x03, 0x261: 0x03, 0x262: 0x03, 0x263: 0x03, 0x264: 0x03, 0x265: 0x03, 0x266: 0x03, 0x267: 0x03, 0x268: 0x03, 0x269: 0x03, 0x26a: 0x03, 0x26b: 0x03, 0x26c: 0x03, 0x26d: 0x03, 0x26e: 0x03, 0x26f: 0x03, 0x270: 0x03, 0x271: 0x03, 0x272: 0x03, 0x273: 0x03, 0x274: 0x03, 0x275: 0x03, 0x276: 0x03, 0x277: 0x03, 0x278: 0x03, 0x279: 0x03, 0x27a: 0x03, 0x27b: 0x03, 0x27c: 0x03, 0x27d: 0x03, 0x27e: 0x03, 0x27f: 0x03, // Block 0xa, offset 0x280 0x280: 0x03, 0x281: 0x03, 0x282: 0x03, 0x283: 0x03, 0x284: 0x03, 0x285: 0x03, 0x286: 0x03, 0x287: 0x03, 0x288: 0x03, 0x289: 0x03, 0x28a: 0x03, 0x28b: 0x03, 0x28c: 0x03, 0x28d: 0x03, 0x28e: 0x03, 0x28f: 0x03, 0x290: 0x03, 0x291: 0x03, 0x292: 0x03, 0x293: 0x03, 0x294: 0x03, 0x295: 0x03, 0x296: 0x03, 0x297: 0x03, 0x298: 0x03, 0x299: 0x03, 0x29a: 0x03, 0x29b: 0x03, 0x29c: 0x03, 0x29d: 0x03, 0x29e: 0x9d, 0x29f: 0x9e, // Block 0xb, offset 0x2c0 0x2ec: 0x9f, 0x2ed: 0xa0, 0x2ee: 0xa1, 0x2ef: 0xa2, 0x2f0: 0x03, 0x2f1: 0x03, 0x2f2: 0x03, 0x2f3: 0x03, 0x2f4: 0xa3, 0x2f5: 0xa4, 0x2f6: 0xa5, 0x2f7: 0xa6, 0x2f8: 0xa7, 0x2f9: 0xa8, 0x2fa: 0x03, 0x2fb: 0xa9, 0x2fc: 0xaa, 0x2fd: 0xab, 0x2fe: 0xac, 0x2ff: 0xad, // Block 0xc, offset 0x300 0x300: 0xae, 0x301: 0xaf, 0x302: 0x03, 0x303: 0xb0, 0x305: 0xb1, 0x307: 0xb2, 0x30a: 0xb3, 0x30b: 0xb4, 0x30c: 0xb5, 0x30d: 0xb6, 0x30e: 0xb7, 0x30f: 0xb8, 0x310: 0x03, 0x311: 0x03, 0x312: 0xb9, 0x313: 0xba, 0x314: 0xbb, 0x315: 0xbc, 0x316: 0xbd, 0x317: 0x8f, 0x318: 0x03, 0x319: 0x03, 0x31a: 0x03, 0x31b: 0x03, 0x31c: 0xbe, 0x31d: 0xbf, 0x31e: 0xc0, 0x320: 0xc1, 0x321: 0xc2, 0x322: 0xc3, 0x323: 0xc4, 0x324: 0xc5, 0x325: 0xc6, 0x326: 0xc7, 0x328: 0xc8, 0x329: 0xc9, 0x32a: 0xca, 0x32b: 0xcb, 0x32c: 0x4b, 0x32d: 0xcc, 0x32e: 0xcd, 0x330: 0x03, 0x331: 0xce, 0x332: 0xcf, 0x333: 0xcf, 0x334: 0xd0, 0x335: 0xd1, 0x336: 0xd2, 0x33a: 0xd3, 0x33b: 0xd4, 0x33c: 0xd5, 0x33d: 0xd6, 0x33e: 0xd7, 0x33f: 0xd8, // Block 0xd, offset 0x340 0x340: 0xd9, 0x341: 0xda, 0x342: 0xdb, 0x343: 0xdc, 0x344: 0xdd, 0x345: 0xde, 0x346: 0xdf, 0x347: 0xe0, 0x348: 0xe1, 0x349: 0xe2, 0x34a: 0xe3, 0x34b: 0xe4, 0x34c: 0xe5, 0x34d: 0xe6, 0x34e: 0xe7, 0x34f: 0xe8, 0x350: 0xe9, 0x351: 0xea, 0x352: 0xeb, 0x353: 0xec, 0x356: 0xed, 0x357: 0xee, 0x358: 0xeb, 0x359: 0xef, 0x35a: 0xf0, 0x35b: 0xf1, 0x35c: 0xf2, 0x360: 0xf3, 0x362: 0xf4, 0x363: 0xf5, 0x364: 0xf6, 0x365: 0xf7, 0x366: 0xf8, 0x367: 0xf9, 0x368: 0xfa, 0x369: 0xfb, 0x36a: 0xfc, 0x36b: 0x49, 0x36d: 0xfd, 0x36f: 0xfe, 0x370: 0xff, 0x371: 0x100, 0x372: 0x101, 0x374: 0x102, 0x375: 0x103, 0x376: 0x104, 0x377: 0x105, 0x37b: 0x106, 0x37c: 0x107, 0x37d: 0x108, 0x37e: 0x109, // Block 0xe, offset 0x380 0x380: 0x03, 0x381: 0x03, 0x382: 0x03, 0x383: 0x03, 0x384: 0x03, 0x385: 0x03, 0x386: 0x03, 0x387: 0x03, 0x388: 0x03, 0x389: 0x03, 0x38a: 0x03, 0x38b: 0x03, 0x38c: 0x03, 0x38d: 0x03, 0x38e: 0xc6, 0x390: 0x03, 0x391: 0x10a, 0x392: 0x03, 0x393: 0x03, 0x394: 0x03, 0x395: 0x10b, 0x3be: 0xa4, 0x3bf: 0x10c, // Block 0xf, offset 0x3c0 0x3c0: 0x03, 0x3c1: 0x03, 0x3c2: 0x03, 0x3c3: 0x03, 0x3c4: 0x03, 0x3c5: 0x03, 0x3c6: 0x03, 0x3c7: 0x03, 0x3c8: 0x03, 0x3c9: 0x03, 0x3ca: 0x03, 0x3cb: 0x03, 0x3cc: 0x03, 0x3cd: 0x03, 0x3ce: 0x03, 0x3cf: 0x03, 0x3d0: 0x10d, 0x3d1: 0x10e, 0x3d2: 0x03, 0x3d3: 0x03, 0x3d4: 0x03, 0x3d5: 0x03, 0x3d6: 0x03, 0x3d7: 0x03, 0x3d8: 0x03, 0x3d9: 0x03, 0x3da: 0x03, 0x3db: 0x03, 0x3dc: 0x03, 0x3dd: 0x03, 0x3de: 0x03, 0x3df: 0x03, 0x3e0: 0x03, 0x3e1: 0x03, 0x3e2: 0x03, 0x3e3: 0x03, 0x3e4: 0x03, 0x3e5: 0x03, 0x3e6: 0x03, 0x3e7: 0x03, 0x3e8: 0x03, 0x3e9: 0x03, 0x3ea: 0x03, 0x3eb: 0x03, 0x3ec: 0x03, 0x3ed: 0x03, 0x3ee: 0x03, 0x3ef: 0x03, 0x3f0: 0x03, 0x3f1: 0x03, 0x3f2: 0x03, 0x3f3: 0x03, 0x3f4: 0x03, 0x3f5: 0x03, 0x3f6: 0x03, 0x3f7: 0x03, 0x3f8: 0x03, 0x3f9: 0x03, 0x3fa: 0x03, 0x3fb: 0x03, 0x3fc: 0x03, 0x3fd: 0x03, 0x3fe: 0x03, 0x3ff: 0x03, // Block 0x10, offset 0x400 0x400: 0x03, 0x401: 0x03, 0x402: 0x03, 0x403: 0x03, 0x404: 0x03, 0x405: 0x03, 0x406: 0x03, 0x407: 0x03, 0x408: 0x03, 0x409: 0x03, 0x40a: 0x03, 0x40b: 0x03, 0x40c: 0x03, 0x40d: 0x03, 0x40e: 0x03, 0x40f: 0xb0, 0x410: 0x03, 0x411: 0x03, 0x412: 0x03, 0x413: 0x03, 0x414: 0x03, 0x415: 0x03, 0x416: 0x03, 0x417: 0x03, 0x418: 0x03, 0x419: 0x10f, // Block 0x11, offset 0x440 0x444: 0x110, 0x460: 0x03, 0x461: 0x03, 0x462: 0x03, 0x463: 0x03, 0x464: 0x03, 0x465: 0x03, 0x466: 0x03, 0x467: 0x03, 0x468: 0x49, 0x469: 0x111, 0x46a: 0x112, 0x46b: 0x113, 0x46c: 0x114, 0x46d: 0x115, 0x46e: 0x116, 0x475: 0x117, 0x479: 0x03, 0x47a: 0x118, 0x47b: 0x119, 0x47c: 0x03, 0x47d: 0x11a, 0x47e: 0x11b, 0x47f: 0x11c, // Block 0x12, offset 0x480 0x4bf: 0x11d, // Block 0x13, offset 0x4c0 0x4c0: 0x11e, 0x4c4: 0x11f, 0x4c5: 0x120, 0x4f0: 0x03, 0x4f1: 0x121, 0x4f2: 0x122, // Block 0x14, offset 0x500 0x533: 0x123, 0x53c: 0x124, 0x53d: 0x125, // Block 0x15, offset 0x540 0x545: 0x126, 0x546: 0x127, 0x549: 0x128, 0x550: 0x03, 0x551: 0x129, 0x552: 0x12a, 0x553: 0x12b, 0x554: 0x12c, 0x555: 0x12d, 0x556: 0x03, 0x557: 0x03, 0x558: 0x03, 0x559: 0x03, 0x55a: 0x12e, 0x55b: 0x12f, 0x55c: 0x130, 0x55d: 0x131, 0x55e: 0x132, 0x55f: 0x133, 0x568: 0x134, 0x569: 0x135, 0x56a: 0x136, 0x57c: 0x137, // Block 0x16, offset 0x580 0x580: 0x138, 0x581: 0x139, 0x582: 0x13a, 0x584: 0x13b, 0x585: 0x13c, 0x58a: 0x13d, 0x58b: 0x13e, 0x593: 0x13f, 0x597: 0x140, 0x59b: 0x141, 0x59f: 0x142, 0x5a0: 0x03, 0x5a1: 0x03, 0x5a2: 0x03, 0x5a3: 0x143, 0x5a4: 0x03, 0x5a5: 0x144, 0x5b8: 0x145, 0x5b9: 0x146, 0x5ba: 0x147, // Block 0x17, offset 0x5c0 0x5c0: 0x148, 0x5c2: 0x149, 0x5c3: 0x14a, 0x5c4: 0x14b, 0x5c5: 0x14c, 0x5c6: 0x14d, 0x5c7: 0x14e, 0x5c8: 0x14f, 0x5c9: 0x150, 0x5ca: 0x151, 0x5cb: 0x151, 0x5cc: 0x152, 0x5cd: 0x151, 0x5ce: 0x153, 0x5cf: 0x154, 0x5d0: 0x151, 0x5d1: 0x151, 0x5d2: 0x151, 0x5d3: 0x155, 0x5d4: 0x156, 0x5d5: 0x157, 0x5d6: 0x158, 0x5d7: 0x159, 0x5d8: 0x151, 0x5d9: 0x15a, 0x5da: 0x151, 0x5db: 0x15b, 0x5df: 0x15c, 0x5e0: 0x15d, 0x5e1: 0x15e, 0x5e2: 0x15f, 0x5e3: 0x160, 0x5e4: 0x161, 0x5e5: 0x162, 0x5e6: 0x151, 0x5e7: 0x151, 0x5e9: 0x163, 0x5ea: 0x151, 0x5eb: 0x151, 0x5ef: 0x123, 0x5f0: 0x151, 0x5f1: 0x151, 0x5f2: 0x151, 0x5f3: 0x151, 0x5f4: 0x151, 0x5f5: 0x151, 0x5f6: 0x151, 0x5f7: 0x151, 0x5f8: 0x151, 0x5f9: 0x151, 0x5fa: 0x151, 0x5fb: 0x151, 0x5fc: 0x151, 0x5fd: 0x151, 0x5fe: 0x151, 0x5ff: 0x156, // Block 0x18, offset 0x600 0x610: 0x0a, 0x611: 0x0b, 0x612: 0x0c, 0x613: 0x0d, 0x614: 0x0e, 0x616: 0x0f, 0x61a: 0x10, 0x61b: 0x11, 0x61c: 0x12, 0x61d: 0x13, 0x61e: 0x14, 0x61f: 0x15, // Block 0x19, offset 0x640 0x640: 0x164, 0x641: 0x05, 0x644: 0x05, 0x645: 0x05, 0x646: 0x05, 0x647: 0x165, // Block 0x1a, offset 0x680 0x6a0: 0x17, } golang-github-clipperhouse-uax29-2.7.0/sentences/000077500000000000000000000000001515045622700217135ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/sentences/README.md000066400000000000000000000052711515045622700231770ustar00rootroot00000000000000An implementation of sentence boundaries from [Unicode text segmentation](https://unicode.org/reports/tr29/#Sentence_Boundaries) (UAX 29), for Unicode 17. [![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/uax29/v2/sentences.svg)](https://pkg.go.dev/github.com/clipperhouse/uax29/v2/sentences) ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg) ## Quick start ``` go get "github.com/clipperhouse/uax29/v2/sentences" ``` ```go import "github.com/clipperhouse/uax29/v2/sentences" text := "Hello, 世界. Nice dog! 👍🐶" tokens := sentences.FromString(text) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current sentence } ``` ## Conformance We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-36.html#Tests29). ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg) ## APIs ### If you have a `string` ```go text := "Hello, 世界. Nice dog! 👍🐶" tokens := sentences.FromString(text) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current sentence } ``` ### If you have an `io.Reader` `FromReader` embeds a [`bufio.Scanner`](https://pkg.go.dev/bufio#Scanner), so just use those methods. ```go r := getYourReader() // from a file or network maybe tokens := sentences.FromReader(r) for tokens.Scan() { // Scan() returns true until error or EOF fmt.Println(tokens.Text()) // Do something with the current sentence } if tokens.Err() != nil { // Check the error log.Fatal(tokens.Err()) } ``` ### If you have a `[]byte` ```go b := []byte("Hello, 世界. Nice dog! 👍🐶") tokens := sentences.FromBytes(b) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current sentence } ``` ### Performance On a Mac M2 laptop, we see around 35MB/s, or around 180 thousand sentences per second. You should see ~constant memory, and no allocations. ### Invalid inputs Invalid UTF-8 input is considered undefined behavior. We test to ensure that bad inputs will not cause pathological outcomes, such as a panic or infinite loop. Callers should expect “garbage-in, garbage-out”. Your pipeline should probably include a call to [`utf8.Valid()`](https://pkg.go.dev/unicode/utf8#Valid). golang-github-clipperhouse-uax29-2.7.0/sentences/bytes_test.go000066400000000000000000000046241515045622700244350ustar00rootroot00000000000000package sentences_test import ( "bytes" "reflect" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/sentences" "github.com/clipperhouse/uax29/v2/testdata" ) func TestBytesUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { test := test var all [][]byte tokens := sentences.FromBytes(test.input) for tokens.Next() { all = append(all, tokens.Value()) } if !reflect.DeepEqual(all, test.expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, all, test.comment) } else { passed++ } } if len(unicodeTests) != passed+failed { t.Errorf("Incomplete %d tests: passed %d, failed %d", len(unicodeTests), passed, failed) } } func TestBytesRoundtrip(t *testing.T) { t.Parallel() const runs = 100 tokens := sentences.FromBytes(nil) for i := 0; i < runs; i++ { input := getRandomBytes() tokens.SetText(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatal("input bytes are not the same as output bytes") } } } func TestBytesInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } tokens := sentences.FromBytes(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as output bytes") } } func BenchmarkBytes(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := sentences.FromBytes(file) for tokens.Next() { _ = tokens.Value() } } } func BenchmarkUnicodeTests(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := sentences.FromBytes(file) for tokens.Next() { _ = tokens.Value() } } } golang-github-clipperhouse-uax29-2.7.0/sentences/fuzz_test.go000066400000000000000000000063361515045622700243070ustar00rootroot00000000000000package sentences_test import ( "bytes" mathrand "math/rand" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/sentences" "github.com/clipperhouse/uax29/v2/testdata" ) // FuzzValidShort fuzzes small, valid UTF8 strings. I suspect more, shorter // strings in the corpus lead to more mutation and coverage. True? func FuzzValidShort(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } // unicode test suite for _, test := range unicodeTests { f.Add(test.input) } // multi-lingual text, as small-ish lines file, err := testdata.Sample() if err != nil { f.Error(err) } lines := bytes.Split(file, []byte("\n")) for _, line := range lines { f.Add(line) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := sentences.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzValidLong fuzzes longer, valid UTF8 strings. func FuzzValidLong(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } // add multi-lingual text, as decent (paragraph-sized) size chunks file, err := testdata.Sample() if err != nil { f.Error(err) } chunks := bytes.Split(file, []byte("\n\n\n")) for _, chunk := range chunks { f.Add(chunk) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := sentences.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzInvalid fuzzes invalid UTF8 strings. func FuzzInvalid(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } random := getRandomBytes() const max = 100 const min = 1 pos := 0 for { // random smaller strings ln := mathrand.Intn(max-min) + min if pos+ln > len(random) { break } f.Add(random[pos : pos+ln]) pos += ln } // known invalid utf-8 badUTF8, err := testdata.InvalidUTF8() if err != nil { f.Error(err) } lines := bytes.Split(badUTF8, []byte("\n")) for _, line := range lines { f.Add(line) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := sentences.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } golang-github-clipperhouse-uax29-2.7.0/sentences/iterator.go000066400000000000000000000057141515045622700241020ustar00rootroot00000000000000package sentences // FromString returns an iterator for the sentences in the input string. // Iterate while Next() is true, and access the sentence via Value(). func FromString(s string) *Iterator[string] { return &Iterator[string]{ split: splitFuncString, data: s, } } // FromBytes returns an iterator for the sentences in the input bytes. // Iterate while Next() is true, and access the sentence via Value(). func FromBytes(b []byte) *Iterator[[]byte] { return &Iterator[[]byte]{ split: splitFuncBytes, data: b, } } // Iterator is a generic iterator for sentences in strings or byte slices. type Iterator[T ~string | ~[]byte] struct { split func(T, bool) (int, T, error) data T pos int start int } var ( splitFuncString = splitFunc[string] splitFuncBytes = splitFunc[[]byte] ) // isASCIIAlphanumericOrSpace returns true if b is in [a-zA-Z0-9 ] func isASCIIAlphanumericOrSpace(b byte) bool { return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9') || b == ' ' } // Next advances the iterator to the next sentence. // Returns false when there are no more sentences. func (iter *Iterator[T]) Next() bool { if iter.pos >= len(iter.data) { return false } iter.start = iter.pos // ASCII hot path: skip contiguous ASCII alphanumerics and spaces // These characters never trigger sentence breaks by themselves for iter.pos < len(iter.data) && isASCIIAlphanumericOrSpace(iter.data[iter.pos]) { iter.pos++ } // If we consumed all remaining data, we're done if iter.pos >= len(iter.data) { return true } // If we skipped any ASCII, back up one so splitfunc has "last" context if iter.pos > iter.start { iter.pos-- } // Defer to splitfunc for the rest remaining := iter.data[iter.pos:] advance, _, err := iter.split(remaining, true) if err != nil { panic(err) } if advance <= 0 { panic("splitFunc returned a zero or negative advance") } iter.pos += advance if iter.pos > len(iter.data) { panic("splitFunc advanced beyond end of data") } return true } // Value returns the current sentence. func (iter *Iterator[T]) Value() T { return iter.data[iter.start:iter.pos] } // Start returns the byte position of the current sentence in the original data. func (iter *Iterator[T]) Start() int { return iter.start } // End returns the byte position after the current sentence in the original data. func (iter *Iterator[T]) End() int { return iter.pos } // Reset resets the iterator to the beginning of the data. func (iter *Iterator[T]) Reset() { iter.start = 0 iter.pos = 0 } // SetText sets the data for the iterator to operate on, and resets all state. func (iter *Iterator[T]) SetText(data T) { iter.data = data iter.start = 0 iter.pos = 0 } // First returns the first sentence without advancing the iterator. func (iter *Iterator[T]) First() T { if len(iter.data) == 0 { return iter.data } // Use a copy to leverage Next()'s ASCII optimization cp := *iter cp.pos = 0 cp.start = 0 cp.Next() return cp.Value() } golang-github-clipperhouse-uax29-2.7.0/sentences/reader.go000066400000000000000000000011121515045622700234770ustar00rootroot00000000000000// Package sentences implements Unicode sentence boundaries: https://unicode.org/reports/tr29/#Sentence_Boundaries package sentences import ( "bufio" "io" ) type Scanner struct { *bufio.Scanner } // FromReader returns a Scanner, to split sentences per // https://unicode.org/reports/tr29/#Sentence_Boundaries. // // It embeds a [bufio.Scanner], so you can use its methods. // // Iterate through sentences by calling Scan() until false, then check Err(). func FromReader(r io.Reader) *Scanner { sc := bufio.NewScanner(r) sc.Split(SplitFunc) return &Scanner{ Scanner: sc, } } golang-github-clipperhouse-uax29-2.7.0/sentences/reader_test.go000066400000000000000000000076311515045622700245520ustar00rootroot00000000000000package sentences_test import ( "bytes" "crypto/rand" mathrand "math/rand" "reflect" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/sentences" "github.com/clipperhouse/uax29/v2/testdata" ) func TestScannerUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { test := test var got [][]byte sc := sentences.FromReader(bytes.NewReader(test.input)) for sc.Scan() { got = append(got, sc.Bytes()) } if err := sc.Err(); err != nil { t.Fatal(err) } if !reflect.DeepEqual(got, test.expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, got, test.comment) } else { passed++ } } t.Logf("passed %d, failed %d", passed, failed) } func TestScannerRoundtrip(t *testing.T) { t.Parallel() const runs = 2_000 for i := 0; i < runs; i++ { input := getRandomBytes() r := bytes.NewReader(input) sc := sentences.FromReader(r) var output []byte for sc.Scan() { output = append(output, sc.Bytes()...) } if err := sc.Err(); err != nil { t.Fatal(err) } if !bytes.Equal(output, input) { t.Fatal("input bytes are not the same as scanned bytes") } } } func TestInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() inlen := len(input) if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } r := bytes.NewReader(input) sc := sentences.FromReader(r) var output []byte for sc.Scan() { output = append(output, sc.Bytes()...) } if err := sc.Err(); err != nil { t.Error(err) } outlen := len(output) if inlen != outlen { t.Fatalf("input: %d bytes, output: %d bytes", inlen, outlen) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as scanned bytes") } } func TestNeverZeroAtEOF(t *testing.T) { t.Parallel() // SplitFunc should never return advance = 0 when atEOF. This test is redundant // with the roundtrip test above, but nice to call out this invariant. const runs = 50 atEOF := true for i := 0; i < runs; i++ { input := getRandomBytes() advance, _, _ := sentences.SplitFunc(input, atEOF) if advance == 0 { t.Errorf("advance should never be zero (atEOF %t)", atEOF) } } } func TestNeverErr(t *testing.T) { t.Parallel() // SplitFunc should never return an error. This test is redundant // with the roundtrip test above, but nice to call out this invariant. const runs = 50 atEOFs := []bool{true, false} for i := 0; i < runs; i++ { for _, atEOF := range atEOFs { input := getRandomBytes() _, _, err := sentences.SplitFunc(input, atEOF) if err != nil { t.Errorf("SplitFunc should never error (atEOF %t)", atEOF) } } } } func getRandomBytes() []byte { const max = 10000 const min = 1 len := mathrand.Intn(max-min) + min b := make([]byte, len) _, _ = rand.Read(b) return b } func BenchmarkScannerMultilingual(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } b.ResetTimer() b.SetBytes(int64(len(file))) r := bytes.NewReader(file) for i := 0; i < b.N; i++ { r.Reset(file) sc := sentences.FromReader(r) for sc.Scan() { _ = sc.Bytes() } if err := sc.Err(); err != nil { b.Error(err) } } } func BenchmarkScannerUnicodeTests(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() b.ResetTimer() b.SetBytes(int64(len(file))) r := bytes.NewReader(file) for i := 0; i < b.N; i++ { r.Reset(file) sc := sentences.FromReader(r) for sc.Scan() { _ = sc.Bytes() } if err := sc.Err(); err != nil { b.Error(err) } } } golang-github-clipperhouse-uax29-2.7.0/sentences/seek.go000066400000000000000000000020121515045622700231640ustar00rootroot00000000000000package sentences const notfound = -1 // subsequent looks ahead in the buffer until it hits a rune in properties, // ignoring runes with the _Ignore property per SB5 func subsequent[T ~string | ~[]byte](properties property, data T, atEOF bool) (advance int, more bool) { i := 0 for i < len(data) { lookup, w := lookup(data[i:]) if w == 0 { if atEOF { // Nothing more to evaluate return notfound, false } // More to evaluate - return notfound to indicate no match found yet return notfound, true } if lookup.is(_Ignore) { i += w continue } if lookup.is(properties) { // Found it return i, false } // If we see a non-ignored character that doesn't match, // the property is definitely not "immediately subsequent" return notfound, false } // If we reach here, we've only seen ignored characters or incomplete runes if atEOF { // Nothing more to evaluate return notfound, false } // Need more - return notfound to indicate no match found yet return notfound, true } golang-github-clipperhouse-uax29-2.7.0/sentences/seek_test.go000066400000000000000000000075321515045622700242370ustar00rootroot00000000000000package sentences import ( "testing" ) func TestSubsequent(t *testing.T) { tests := []struct { name string properties property data []byte atEOF bool expectAdvance int expectMore bool description string }{ // Basic found cases { name: "found_immediately", properties: _Numeric, data: []byte("123"), atEOF: true, expectAdvance: 0, expectMore: false, description: "Should find numeric character at start", }, { name: "found_after_ignored_chars", properties: _Numeric, data: []byte("\u200d1"), // ZWJ + '1' atEOF: true, expectAdvance: 3, // ZWJ is 3 bytes expectMore: false, description: "Should skip ignored ZWJ and find numeric", }, { name: "not_found_definitive", properties: _Numeric, data: []byte("abc"), atEOF: true, expectAdvance: notfound, expectMore: false, description: "Should not find numeric in letters", }, { name: "not_found_immediate_non_match", properties: _Numeric, data: []byte("a"), atEOF: true, expectAdvance: notfound, expectMore: false, description: "Should not find numeric in single letter", }, { name: "empty_data_at_eof", properties: _Numeric, data: []byte(""), atEOF: true, expectAdvance: notfound, expectMore: false, description: "Empty data at EOF should return not found", }, { name: "empty_data_not_at_eof", properties: _Numeric, data: []byte(""), atEOF: false, expectAdvance: notfound, expectMore: true, description: "Empty data not at EOF should request more data", }, { name: "only_ignored_at_eof", properties: _Numeric, data: []byte("\u200d"), // ZWJ only atEOF: true, expectAdvance: notfound, expectMore: false, description: "Only ignored chars at EOF should return not found", }, { name: "only_ignored_not_at_eof", properties: _Numeric, data: []byte("\u200d"), // ZWJ only atEOF: false, expectAdvance: notfound, expectMore: true, description: "Only ignored chars not at EOF should request more data", }, { name: "incomplete_rune_at_eof", properties: _Numeric, data: []byte{0xE2, 0x80}, // Incomplete ZWJ (needs 3 bytes) atEOF: true, expectAdvance: notfound, expectMore: false, description: "Incomplete rune at EOF should return not found", }, { name: "incomplete_rune_not_at_eof", properties: _Numeric, data: []byte{0xE2, 0x80}, // Incomplete ZWJ atEOF: false, expectAdvance: notfound, expectMore: true, description: "Incomplete rune not at EOF should request more data", }, { name: "ignored_then_found", properties: _Numeric, data: []byte("\u200d\u200d1"), // ZWJ + ZWJ + '1' atEOF: true, expectAdvance: 6, // Two ZWJs = 6 bytes expectMore: false, description: "Should skip multiple ignored chars and find numeric", }, { name: "find_any_of_multiple_properties", properties: _Numeric | _Upper, data: []byte("1"), atEOF: true, expectAdvance: 0, expectMore: false, description: "Should find any matching property", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { advance, more := subsequent(tt.properties, tt.data, tt.atEOF) if advance != tt.expectAdvance { t.Errorf("advance = %d, expected %d\nDescription: %s", advance, tt.expectAdvance, tt.description) } if more != tt.expectMore { t.Errorf("more = %v, expected %v\nDescription: %s", more, tt.expectMore, tt.description) } }) } } golang-github-clipperhouse-uax29-2.7.0/sentences/splitfunc.go000066400000000000000000000117411515045622700242550ustar00rootroot00000000000000package sentences import ( "bufio" ) // is determines if lookup intersects propert(ies) func (lookup property) is(properties property) bool { return (lookup & properties) != 0 } const ( _SATerm = _STerm | _ATerm _ParaSep = _Sep | _CR | _LF _Ignore = _Extend | _Format ) // SplitFunc is a bufio.SplitFunc implementation of sentence segmentation, for use with bufio.Scanner. // // See https://unicode.org/reports/tr29/#Sentence_Boundaries. var SplitFunc bufio.SplitFunc = splitFunc[[]byte] // SplitFunc is a bufio.SplitFunc implementation of word segmentation, for use with bufio.Scanner. func splitFunc[T ~string | ~[]byte](data T, atEOF bool) (advance int, token T, err error) { var empty T if len(data) == 0 { return 0, empty, nil } // These vars are stateful across loop iterations var pos int var lastExIgnore property // "last excluding ignored categories" var lastLastExIgnore property // "last one before that" var lastExIgnoreSp property var lastExIgnoreClose property var lastExIgnoreSpClose property var lastExIgnoreParaSepSpClose property // Rules are usually of the form Cat1 × Cat2; "current" refers to the first property // to the right of the ×, from which we look back or forward current, w := lookup(data[pos:]) if w == 0 { if !atEOF { // Rune extends past current data, request more return 0, empty, nil } pos = len(data) return pos, data[:pos], nil } // https://unicode.org/reports/tr29/#SB1 // Start of text always advances pos += w main: for { eot := pos == len(data) // "end of text" if eot { if !atEOF { // Token extends past current data, request more return 0, empty, nil } // https://unicode.org/reports/tr29/#SB2 break } // Remember previous properties to avoid lookups/lookbacks last := current if !last.is(_Ignore) { lastLastExIgnore = lastExIgnore lastExIgnore = last } if !lastExIgnore.is(_Sp) { lastExIgnoreSp = lastExIgnore } if !lastExIgnore.is(_Close) { lastExIgnoreClose = lastExIgnore } if !lastExIgnoreSp.is(_Close) { lastExIgnoreSpClose = lastExIgnoreSp } if !lastExIgnoreSpClose.is(_ParaSep) { lastExIgnoreParaSepSpClose = lastExIgnoreSpClose } current, w = lookup(data[pos:]) if w == 0 { if atEOF { // Just return the bytes, we can't do anything with them pos = len(data) break } // Rune extends past current data, request more return 0, empty, nil } // Optimization: no rule can possibly apply if current|last == 0 { // i.e. both are zero pos += w continue } // https://unicode.org/reports/tr29/#SB3 if current.is(_LF) && last.is(_CR) { pos += w continue } // https://unicode.org/reports/tr29/#SB4 if last.is(_ParaSep) { break } // https://unicode.org/reports/tr29/#SB5 if current.is(_Extend | _Format) { pos += w continue } // SB5 applies to subsequent rules; there is an implied "ignoring Extend & Format" // https://unicode.org/reports/tr29/#Sentence_Boundary_Rules // The previous/subsequent methods are shorthand for "seek a property but skip over Extend & Format on the way" // https://unicode.org/reports/tr29/#SB6 if current.is(_Numeric) && lastExIgnore.is(_ATerm) { pos += w continue } // https://unicode.org/reports/tr29/#SB7 if current.is(_Upper) && lastExIgnore.is(_ATerm) && lastLastExIgnore.is(_Upper|_Lower) { pos += w continue } // https://unicode.org/reports/tr29/#SB8 if lastExIgnoreSpClose.is(_ATerm) { p := pos // ( ¬(OLetter | Upper | Lower | ParaSep | SATerm) )* // Zero or more of not-the-above properties for p < len(data) { lookup, w := lookup(data[p:]) if w == 0 { if atEOF { // Just return the bytes, we can't do anything with them pos = len(data) break main } // Rune extends past current data, request more return 0, empty, nil } if lookup.is(_OLetter | _Upper | _Lower | _ParaSep | _SATerm) { break } p += w } advance, more := subsequent(_Lower, data[p:], atEOF) if more { // Rune or token extends past current data, request more return 0, empty, nil } if advance != notfound { pos = p + advance continue } } // https://unicode.org/reports/tr29/#SB8a if current.is(_SContinue|_SATerm) && lastExIgnoreSpClose.is(_SATerm) { pos += w continue } // https://unicode.org/reports/tr29/#SB9 if current.is(_Close|_Sp|_ParaSep) && lastExIgnoreClose.is(_SATerm) { pos += w continue } // https://unicode.org/reports/tr29/#SB10 if current.is(_Sp|_ParaSep) && lastExIgnoreSpClose.is(_SATerm) { pos += w continue } // https://unicode.org/reports/tr29/#SB11 if lastExIgnore.is(_SATerm) || (lastExIgnore.is(_Close) && lastExIgnoreClose.is(_SATerm)) || (lastExIgnore.is(_Sp) && lastExIgnoreSpClose.is(_SATerm)) || (lastExIgnore.is(_ParaSep) && lastExIgnoreParaSepSpClose.is(_SATerm)) { break } // https://unicode.org/reports/tr29/#SB998 pos += w } // Return token return pos, data[:pos], nil } golang-github-clipperhouse-uax29-2.7.0/sentences/string_test.go000066400000000000000000000352701515045622700246160ustar00rootroot00000000000000package sentences_test import ( "bytes" "reflect" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/sentences" "github.com/clipperhouse/uax29/v2/testdata" ) func TestStringUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { test := test var all []string tokens := sentences.FromString(string(test.input)) for tokens.Next() { all = append(all, tokens.Value()) } expected := make([]string, len(test.expected)) for i, v := range test.expected { expected[i] = string(v) } if !reflect.DeepEqual(all, expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, all, test.comment) } else { passed++ } } if len(unicodeTests) != passed+failed { t.Errorf("Incomplete %d tests: passed %d, failed %d", len(unicodeTests), passed, failed) } } func TestStringRoundtrip(t *testing.T) { t.Parallel() const runs = 100 for i := 0; i < runs; i++ { input := string(getRandomBytes()) tokens := sentences.FromString(input) var output string for tokens.Next() { output += tokens.Value() } if output != input { t.Fatal("input bytes are not the same as output bytes") } } } func TestStringInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } tokens := sentences.FromString(string(input)) var output string for tokens.Next() { output += tokens.Value() } if output != string(input) { t.Fatalf("input bytes are not the same as output bytes") } } // TestASCIIOptimization tests edge cases for the ASCII hot path optimization // in the iterator. The optimization fast-forwards over [a-zA-Z0-9 ] and defers // to splitfunc for everything else. func TestASCIIOptimization(t *testing.T) { t.Parallel() tests := []struct { name string input string expected []string }{ // Basic sentence breaks after ASCII text { name: "period after ASCII", input: "Hello world.", expected: []string{"Hello world."}, }, { name: "exclamation after ASCII", input: "Hello world!", expected: []string{"Hello world!"}, }, { name: "question after ASCII", input: "Hello world?", expected: []string{"Hello world?"}, }, // Multiple sentences { name: "two sentences with space", input: "Hello. World.", expected: []string{"Hello. ", "World."}, }, { name: "no space after period stays together", input: "Hello.World.", expected: []string{"Hello.World."}, // SB7: Lower ATerm × Upper = no break }, { name: "three sentences", input: "One. Two. Three.", expected: []string{"One. ", "Two. ", "Three."}, }, // Numbers and decimals (SB6: ATerm × Numeric) { name: "decimal number", input: "The value is 3.14 exactly.", expected: []string{"The value is 3.14 exactly."}, }, { name: "price", input: "It costs 9.99 dollars.", expected: []string{"It costs 9.99 dollars."}, }, { name: "version number", input: "Use version 2.0 now.", expected: []string{"Use version 2.0 now."}, }, // Abbreviations and SB7 (Lower ATerm × Upper = no break when no space) { name: "abbreviation with space breaks", input: "Dr. Smith is here.", expected: []string{"Dr. ", "Smith is here."}, // SB11: space after ATerm causes break }, { name: "abbreviation no space stays together", input: "Dr.Smith is here.", expected: []string{"Dr.Smith is here."}, // SB7: Lower ATerm × Upper = no break }, { name: "abbreviation U.S.A followed by lowercase", input: "Visit the U.S.A. today.", expected: []string{"Visit the U.S.A. today."}, // SB8: ATerm Sp × Lower = no break }, { name: "abbreviation U.S.A followed by uppercase", input: "Visit the U.S.A. Today.", expected: []string{"Visit the U.S.A. ", "Today."}, // SB11: Sp after ATerm, then Upper = break }, // Newlines and paragraph separators { name: "newline after ASCII", input: "Hello\nWorld", expected: []string{"Hello\n", "World"}, }, { name: "CRLF after ASCII", input: "Hello\r\nWorld", expected: []string{"Hello\r\n", "World"}, }, // Pure ASCII with no breaks { name: "all ASCII alphanumeric", input: "The quick brown fox jumps over 42 lazy dogs", expected: []string{"The quick brown fox jumps over 42 lazy dogs"}, }, { name: "all ASCII letters", input: "abcdefghijklmnopqrstuvwxyz", expected: []string{"abcdefghijklmnopqrstuvwxyz"}, }, // Edge: single char before terminator (tests back-up logic) { name: "single char sentences", input: "A. B. C.", expected: []string{"A. ", "B. ", "C."}, }, // Edge: terminator immediately after fast-forward position { name: "long ASCII then period", input: "This is a very long sentence with many words. Next.", expected: []string{"This is a very long sentence with many words. ", "Next."}, }, // Edge: mixed numbers and sentence breaks { name: "number then sentence break", input: "Buy 3. Get 1 free.", expected: []string{"Buy 3. ", "Get 1 free."}, }, // Edge: ASCII followed by non-ASCII { name: "ASCII then emoji", input: "Hello 😀 world.", expected: []string{"Hello 😀 world."}, }, { name: "ASCII then accented", input: "Hello café world.", expected: []string{"Hello café world."}, }, // Edge: spaces around terminators { name: "multiple spaces after period", input: "Hello. World.", expected: []string{"Hello. ", "World."}, }, // Edge: empty and minimal { name: "single word", input: "Hello", expected: []string{"Hello"}, }, { name: "single char", input: "A", expected: []string{"A"}, }, { name: "just spaces", input: " ", expected: []string{" "}, }, // Edge: alternating ASCII and non-ASCII { name: "alternating", input: "A中B中C.", expected: []string{"A中B中C."}, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var got []string iter := sentences.FromString(tt.input) for iter.Next() { got = append(got, iter.Value()) } if !reflect.DeepEqual(got, tt.expected) { t.Errorf("input %q:\n expected: %q\n got: %q", tt.input, tt.expected, got) } // Also verify roundtrip var combined string for _, s := range got { combined += s } if combined != tt.input { t.Errorf("roundtrip failed: input %q, combined %q", tt.input, combined) } }) } } func TestFirstASCIIOptimization(t *testing.T) { t.Parallel() tests := []struct { name string input string expected string }{ // Pure ASCII hot path - all data consumed { name: "all ASCII alphanumeric no terminator", input: "hello world", expected: "hello world", }, { name: "all ASCII with numbers", input: "abc123 def456", expected: "abc123 def456", }, { name: "trailing space", input: "hello ", expected: "hello ", }, { name: "only spaces", input: " ", expected: " ", }, // ASCII then terminator triggers back-up + splitFunc { name: "period ends sentence", input: "Hello world.", expected: "Hello world.", }, { name: "period then more text", input: "Hello. World.", expected: "Hello. ", }, { name: "exclamation ends sentence", input: "Hello!", expected: "Hello!", }, { name: "question ends sentence", input: "Hello?", expected: "Hello?", }, { name: "newline breaks sentence", input: "Hello\nWorld", expected: "Hello\n", }, // ASCII then non-ASCII triggers back-up + splitFunc { name: "ASCII then emoji continues", input: "Hello 😀 world.", expected: "Hello 😀 world.", }, { name: "ASCII then accented continues", input: "Hello café.", expected: "Hello café.", }, // Single character edge cases { name: "single ASCII letter", input: "A", expected: "A", }, { name: "single space", input: " ", expected: " ", }, { name: "single period", input: ".", expected: ".", }, // Non-ASCII at start (no hot path) { name: "starts with non-ASCII", input: "Éclair is tasty.", expected: "Éclair is tasty.", }, { name: "starts with emoji", input: "🎉 Party time!", expected: "🎉 Party time!", }, // Back-up logic edge cases { name: "one char before terminator", input: "A. B.", expected: "A. ", }, { name: "two chars before terminator", input: "AB. CD.", expected: "AB. ", }, // Decimal numbers (SB6: ATerm × Numeric) { name: "decimal stays together", input: "Pi is 3.14 exactly.", expected: "Pi is 3.14 exactly.", }, { name: "version number", input: "Use v2.0 now.", expected: "Use v2.0 now.", }, // Abbreviations { name: "abbreviation Dr. with space breaks", input: "Dr. Smith arrived.", expected: "Dr. ", }, { name: "abbreviation no space stays", input: "Dr.Smith arrived.", expected: "Dr.Smith arrived.", }, } for _, tt := range tests { t.Run(tt.name+"/string", func(t *testing.T) { iter := sentences.FromString(tt.input) got := iter.First() if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) t.Run(tt.name+"/bytes", func(t *testing.T) { iter := sentences.FromBytes([]byte(tt.input)) got := string(iter.First()) if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) } } func TestFirst(t *testing.T) { t.Parallel() tests := []struct { name string input string expected string }{ { name: "single sentence", input: "Hello world.", expected: "Hello world.", }, { name: "two sentences", input: "Hello. World.", expected: "Hello. ", }, { name: "ASCII no terminator", input: "hello world", expected: "hello world", }, { name: "Unicode sentence", input: "Héllo world.", expected: "Héllo world.", }, { name: "empty string", input: "", expected: "", }, { name: "pure ASCII alphanumeric", input: "abc123 def456", expected: "abc123 def456", }, { name: "newline breaks sentence", input: "Hello\nWorld", expected: "Hello\n", }, { name: "exclamation ends sentence", input: "Hello! World.", expected: "Hello! ", }, { name: "question ends sentence", input: "Hello? World.", expected: "Hello? ", }, { name: "decimal number stays together", input: "The value is 3.14 exactly.", expected: "The value is 3.14 exactly.", }, { name: "abbreviation with space breaks", input: "Dr. Smith is here.", expected: "Dr. ", }, { name: "ASCII then emoji", input: "Hello 😀 world.", expected: "Hello 😀 world.", }, } for _, tt := range tests { t.Run(tt.name+"/string", func(t *testing.T) { iter := sentences.FromString(tt.input) got := iter.First() if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) t.Run(tt.name+"/bytes", func(t *testing.T) { iter := sentences.FromBytes([]byte(tt.input)) got := string(iter.First()) if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) } } func BenchmarkStringMultilingual(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } s := string(file) b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := sentences.FromString(s) for tokens.Next() { _ = tokens.Value() } } } // asciiText is realistic English prose for benchmarking the ASCII optimization. // It contains a mix of sentence lengths, punctuation, numbers, and abbreviations. const asciiText = `The quick brown fox jumps over the lazy dog. This sentence contains every letter of the alphabet. How fascinating is that? Very fascinating indeed! Dr. Smith arrived at 9:30 a.m. to discuss the quarterly results. The company earned $3.14 million in Q4. Revenue increased by 12.5 percent year over year. These numbers exceeded all expectations. Programming languages have evolved significantly since the 1950s. FORTRAN was one of the first high-level languages. Today we have Python, Go, Rust, and many others. Each language has its strengths and weaknesses. Which one is best? That depends on your use case. The United States of America declared independence in 1776. The Constitution was ratified in 1788. George Washington became the first president in 1789. These events shaped the modern world. Email addresses like user@example.com are common in text. URLs such as https://www.example.org appear frequently too. Phone numbers like 555-123-4567 need special handling. Version numbers like v2.0.1 should stay together. Short sentences work. Long sentences with many clauses and subclauses that go on and on and contain lots of information can be harder to parse but are still valid English prose that appears in academic writing and legal documents. Medium length sentences offer a good balance between clarity and detail. The meeting is scheduled for Monday at 2 p.m. in Conference Room B. Please bring your laptop and any relevant documents. We will discuss the roadmap for Q1 2024. Attendance is mandatory for all team leads. In conclusion, this benchmark text provides realistic English prose with varied sentence structures, punctuation marks, numbers, abbreviations, and formatting. It should effectively test the ASCII optimization path in the sentence segmentation algorithm.` func BenchmarkStringASCII(b *testing.B) { // Repeat the text to get a substantial size var buf bytes.Buffer for i := 0; i < 100; i++ { buf.WriteString(asciiText) buf.WriteString("\n\n") } s := buf.String() b.ResetTimer() b.SetBytes(int64(len(s))) for i := 0; i < b.N; i++ { tokens := sentences.FromString(s) for tokens.Next() { _ = tokens.Value() } } } func BenchmarkStringUnicodeTests(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() s := string(file) b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := sentences.FromString(s) for tokens.Next() { _ = tokens.Value() } } } golang-github-clipperhouse-uax29-2.7.0/sentences/trie.go000066400000000000000000010727051515045622700232210ustar00rootroot00000000000000package sentences // generated by github.com/clipperhouse/uax29/v2 // from https://www.unicode.org/Public/17.0.0/ucd/auxiliary/SentenceBreakProperty.txt type property uint16 const ( _ATerm property = 1 << iota _CR _Close _Extend _Format _LF _Lower _Numeric _OLetter _SContinue _STerm _Sep _Sp _Upper ) // 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 lookup[T ~string | ~[]byte](s T) (v property, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return sentencesValues[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := sentencesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := sentencesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = sentencesIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := sentencesIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = sentencesIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = sentencesIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // sentencesTrie. Total size: 50688 bytes (49.50 KiB). Checksum: cadfb7ac79c3db52. // type sentencesTrie struct { } // func newSentencesTrie(i int) *sentencesTrie { // return &sentencesTrie{} // } // lookupValue determines the type of block n and looks up the value for b. func lookupValue(n uint32, b byte) property { switch { default: return property(sentencesValues[n<<6+uint32(b)]) } } // sentencesValues: 360 blocks, 23040 entries, 46080 bytes // The third block is the zero block. var sentencesValues = [23040]property{ // Block 0x0, offset 0x0 0x09: 0x1000, 0x0a: 0x0020, 0x0b: 0x1000, 0x0c: 0x1000, 0x0d: 0x0002, 0x20: 0x1000, 0x21: 0x0400, 0x22: 0x0004, 0x27: 0x0004, 0x28: 0x0004, 0x29: 0x0004, 0x2c: 0x0200, 0x2d: 0x0200, 0x2e: 0x0001, 0x30: 0x0080, 0x31: 0x0080, 0x32: 0x0080, 0x33: 0x0080, 0x34: 0x0080, 0x35: 0x0080, 0x36: 0x0080, 0x37: 0x0080, 0x38: 0x0080, 0x39: 0x0080, 0x3a: 0x0200, 0x3b: 0x0200, 0x3f: 0x0400, // Block 0x1, offset 0x40 0x41: 0x2000, 0x42: 0x2000, 0x43: 0x2000, 0x44: 0x2000, 0x45: 0x2000, 0x46: 0x2000, 0x47: 0x2000, 0x48: 0x2000, 0x49: 0x2000, 0x4a: 0x2000, 0x4b: 0x2000, 0x4c: 0x2000, 0x4d: 0x2000, 0x4e: 0x2000, 0x4f: 0x2000, 0x50: 0x2000, 0x51: 0x2000, 0x52: 0x2000, 0x53: 0x2000, 0x54: 0x2000, 0x55: 0x2000, 0x56: 0x2000, 0x57: 0x2000, 0x58: 0x2000, 0x59: 0x2000, 0x5a: 0x2000, 0x5b: 0x0004, 0x5d: 0x0004, 0x61: 0x0040, 0x62: 0x0040, 0x63: 0x0040, 0x64: 0x0040, 0x65: 0x0040, 0x66: 0x0040, 0x67: 0x0040, 0x68: 0x0040, 0x69: 0x0040, 0x6a: 0x0040, 0x6b: 0x0040, 0x6c: 0x0040, 0x6d: 0x0040, 0x6e: 0x0040, 0x6f: 0x0040, 0x70: 0x0040, 0x71: 0x0040, 0x72: 0x0040, 0x73: 0x0040, 0x74: 0x0040, 0x75: 0x0040, 0x76: 0x0040, 0x77: 0x0040, 0x78: 0x0040, 0x79: 0x0040, 0x7a: 0x0040, 0x7b: 0x0004, 0x7d: 0x0004, // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc5: 0x0800, 0xe0: 0x1000, 0xea: 0x0040, 0xeb: 0x0004, 0xed: 0x0010, 0xf5: 0x0040, 0xfa: 0x0040, 0xfb: 0x0004, // Block 0x4, offset 0x100 0x100: 0x2000, 0x101: 0x2000, 0x102: 0x2000, 0x103: 0x2000, 0x104: 0x2000, 0x105: 0x2000, 0x106: 0x2000, 0x107: 0x2000, 0x108: 0x2000, 0x109: 0x2000, 0x10a: 0x2000, 0x10b: 0x2000, 0x10c: 0x2000, 0x10d: 0x2000, 0x10e: 0x2000, 0x10f: 0x2000, 0x110: 0x2000, 0x111: 0x2000, 0x112: 0x2000, 0x113: 0x2000, 0x114: 0x2000, 0x115: 0x2000, 0x116: 0x2000, 0x118: 0x2000, 0x119: 0x2000, 0x11a: 0x2000, 0x11b: 0x2000, 0x11c: 0x2000, 0x11d: 0x2000, 0x11e: 0x2000, 0x11f: 0x0040, 0x120: 0x0040, 0x121: 0x0040, 0x122: 0x0040, 0x123: 0x0040, 0x124: 0x0040, 0x125: 0x0040, 0x126: 0x0040, 0x127: 0x0040, 0x128: 0x0040, 0x129: 0x0040, 0x12a: 0x0040, 0x12b: 0x0040, 0x12c: 0x0040, 0x12d: 0x0040, 0x12e: 0x0040, 0x12f: 0x0040, 0x130: 0x0040, 0x131: 0x0040, 0x132: 0x0040, 0x133: 0x0040, 0x134: 0x0040, 0x135: 0x0040, 0x136: 0x0040, 0x138: 0x0040, 0x139: 0x0040, 0x13a: 0x0040, 0x13b: 0x0040, 0x13c: 0x0040, 0x13d: 0x0040, 0x13e: 0x0040, 0x13f: 0x0040, // Block 0x5, offset 0x140 0x140: 0x2000, 0x141: 0x0040, 0x142: 0x2000, 0x143: 0x0040, 0x144: 0x2000, 0x145: 0x0040, 0x146: 0x2000, 0x147: 0x0040, 0x148: 0x2000, 0x149: 0x0040, 0x14a: 0x2000, 0x14b: 0x0040, 0x14c: 0x2000, 0x14d: 0x0040, 0x14e: 0x2000, 0x14f: 0x0040, 0x150: 0x2000, 0x151: 0x0040, 0x152: 0x2000, 0x153: 0x0040, 0x154: 0x2000, 0x155: 0x0040, 0x156: 0x2000, 0x157: 0x0040, 0x158: 0x2000, 0x159: 0x0040, 0x15a: 0x2000, 0x15b: 0x0040, 0x15c: 0x2000, 0x15d: 0x0040, 0x15e: 0x2000, 0x15f: 0x0040, 0x160: 0x2000, 0x161: 0x0040, 0x162: 0x2000, 0x163: 0x0040, 0x164: 0x2000, 0x165: 0x0040, 0x166: 0x2000, 0x167: 0x0040, 0x168: 0x2000, 0x169: 0x0040, 0x16a: 0x2000, 0x16b: 0x0040, 0x16c: 0x2000, 0x16d: 0x0040, 0x16e: 0x2000, 0x16f: 0x0040, 0x170: 0x2000, 0x171: 0x0040, 0x172: 0x2000, 0x173: 0x0040, 0x174: 0x2000, 0x175: 0x0040, 0x176: 0x2000, 0x177: 0x0040, 0x178: 0x0040, 0x179: 0x2000, 0x17a: 0x0040, 0x17b: 0x2000, 0x17c: 0x0040, 0x17d: 0x2000, 0x17e: 0x0040, 0x17f: 0x2000, // Block 0x6, offset 0x180 0x180: 0x0040, 0x181: 0x2000, 0x182: 0x0040, 0x183: 0x2000, 0x184: 0x0040, 0x185: 0x2000, 0x186: 0x0040, 0x187: 0x2000, 0x188: 0x0040, 0x189: 0x0040, 0x18a: 0x2000, 0x18b: 0x0040, 0x18c: 0x2000, 0x18d: 0x0040, 0x18e: 0x2000, 0x18f: 0x0040, 0x190: 0x2000, 0x191: 0x0040, 0x192: 0x2000, 0x193: 0x0040, 0x194: 0x2000, 0x195: 0x0040, 0x196: 0x2000, 0x197: 0x0040, 0x198: 0x2000, 0x199: 0x0040, 0x19a: 0x2000, 0x19b: 0x0040, 0x19c: 0x2000, 0x19d: 0x0040, 0x19e: 0x2000, 0x19f: 0x0040, 0x1a0: 0x2000, 0x1a1: 0x0040, 0x1a2: 0x2000, 0x1a3: 0x0040, 0x1a4: 0x2000, 0x1a5: 0x0040, 0x1a6: 0x2000, 0x1a7: 0x0040, 0x1a8: 0x2000, 0x1a9: 0x0040, 0x1aa: 0x2000, 0x1ab: 0x0040, 0x1ac: 0x2000, 0x1ad: 0x0040, 0x1ae: 0x2000, 0x1af: 0x0040, 0x1b0: 0x2000, 0x1b1: 0x0040, 0x1b2: 0x2000, 0x1b3: 0x0040, 0x1b4: 0x2000, 0x1b5: 0x0040, 0x1b6: 0x2000, 0x1b7: 0x0040, 0x1b8: 0x2000, 0x1b9: 0x2000, 0x1ba: 0x0040, 0x1bb: 0x2000, 0x1bc: 0x0040, 0x1bd: 0x2000, 0x1be: 0x0040, 0x1bf: 0x0040, // Block 0x7, offset 0x1c0 0x1c0: 0x0040, 0x1c1: 0x2000, 0x1c2: 0x2000, 0x1c3: 0x0040, 0x1c4: 0x2000, 0x1c5: 0x0040, 0x1c6: 0x2000, 0x1c7: 0x2000, 0x1c8: 0x0040, 0x1c9: 0x2000, 0x1ca: 0x2000, 0x1cb: 0x2000, 0x1cc: 0x0040, 0x1cd: 0x0040, 0x1ce: 0x2000, 0x1cf: 0x2000, 0x1d0: 0x2000, 0x1d1: 0x2000, 0x1d2: 0x0040, 0x1d3: 0x2000, 0x1d4: 0x2000, 0x1d5: 0x0040, 0x1d6: 0x2000, 0x1d7: 0x2000, 0x1d8: 0x2000, 0x1d9: 0x0040, 0x1da: 0x0040, 0x1db: 0x0040, 0x1dc: 0x2000, 0x1dd: 0x2000, 0x1de: 0x0040, 0x1df: 0x2000, 0x1e0: 0x2000, 0x1e1: 0x0040, 0x1e2: 0x2000, 0x1e3: 0x0040, 0x1e4: 0x2000, 0x1e5: 0x0040, 0x1e6: 0x2000, 0x1e7: 0x2000, 0x1e8: 0x0040, 0x1e9: 0x2000, 0x1ea: 0x0040, 0x1eb: 0x0040, 0x1ec: 0x2000, 0x1ed: 0x0040, 0x1ee: 0x2000, 0x1ef: 0x2000, 0x1f0: 0x0040, 0x1f1: 0x2000, 0x1f2: 0x2000, 0x1f3: 0x2000, 0x1f4: 0x0040, 0x1f5: 0x2000, 0x1f6: 0x0040, 0x1f7: 0x2000, 0x1f8: 0x2000, 0x1f9: 0x0040, 0x1fa: 0x0040, 0x1fb: 0x0100, 0x1fc: 0x2000, 0x1fd: 0x0040, 0x1fe: 0x0040, 0x1ff: 0x0040, // Block 0x8, offset 0x200 0x200: 0x0100, 0x201: 0x0100, 0x202: 0x0100, 0x203: 0x0100, 0x204: 0x2000, 0x205: 0x2000, 0x206: 0x0040, 0x207: 0x2000, 0x208: 0x2000, 0x209: 0x0040, 0x20a: 0x2000, 0x20b: 0x2000, 0x20c: 0x0040, 0x20d: 0x2000, 0x20e: 0x0040, 0x20f: 0x2000, 0x210: 0x0040, 0x211: 0x2000, 0x212: 0x0040, 0x213: 0x2000, 0x214: 0x0040, 0x215: 0x2000, 0x216: 0x0040, 0x217: 0x2000, 0x218: 0x0040, 0x219: 0x2000, 0x21a: 0x0040, 0x21b: 0x2000, 0x21c: 0x0040, 0x21d: 0x0040, 0x21e: 0x2000, 0x21f: 0x0040, 0x220: 0x2000, 0x221: 0x0040, 0x222: 0x2000, 0x223: 0x0040, 0x224: 0x2000, 0x225: 0x0040, 0x226: 0x2000, 0x227: 0x0040, 0x228: 0x2000, 0x229: 0x0040, 0x22a: 0x2000, 0x22b: 0x0040, 0x22c: 0x2000, 0x22d: 0x0040, 0x22e: 0x2000, 0x22f: 0x0040, 0x230: 0x0040, 0x231: 0x2000, 0x232: 0x2000, 0x233: 0x0040, 0x234: 0x2000, 0x235: 0x0040, 0x236: 0x2000, 0x237: 0x2000, 0x238: 0x2000, 0x239: 0x0040, 0x23a: 0x2000, 0x23b: 0x0040, 0x23c: 0x2000, 0x23d: 0x0040, 0x23e: 0x2000, 0x23f: 0x0040, // Block 0x9, offset 0x240 0x240: 0x2000, 0x241: 0x0040, 0x242: 0x2000, 0x243: 0x0040, 0x244: 0x2000, 0x245: 0x0040, 0x246: 0x2000, 0x247: 0x0040, 0x248: 0x2000, 0x249: 0x0040, 0x24a: 0x2000, 0x24b: 0x0040, 0x24c: 0x2000, 0x24d: 0x0040, 0x24e: 0x2000, 0x24f: 0x0040, 0x250: 0x2000, 0x251: 0x0040, 0x252: 0x2000, 0x253: 0x0040, 0x254: 0x2000, 0x255: 0x0040, 0x256: 0x2000, 0x257: 0x0040, 0x258: 0x2000, 0x259: 0x0040, 0x25a: 0x2000, 0x25b: 0x0040, 0x25c: 0x2000, 0x25d: 0x0040, 0x25e: 0x2000, 0x25f: 0x0040, 0x260: 0x2000, 0x261: 0x0040, 0x262: 0x2000, 0x263: 0x0040, 0x264: 0x2000, 0x265: 0x0040, 0x266: 0x2000, 0x267: 0x0040, 0x268: 0x2000, 0x269: 0x0040, 0x26a: 0x2000, 0x26b: 0x0040, 0x26c: 0x2000, 0x26d: 0x0040, 0x26e: 0x2000, 0x26f: 0x0040, 0x270: 0x2000, 0x271: 0x0040, 0x272: 0x2000, 0x273: 0x0040, 0x274: 0x0040, 0x275: 0x0040, 0x276: 0x0040, 0x277: 0x0040, 0x278: 0x0040, 0x279: 0x0040, 0x27a: 0x2000, 0x27b: 0x2000, 0x27c: 0x0040, 0x27d: 0x2000, 0x27e: 0x2000, 0x27f: 0x0040, // Block 0xa, offset 0x280 0x280: 0x0040, 0x281: 0x2000, 0x282: 0x0040, 0x283: 0x2000, 0x284: 0x2000, 0x285: 0x2000, 0x286: 0x2000, 0x287: 0x0040, 0x288: 0x2000, 0x289: 0x0040, 0x28a: 0x2000, 0x28b: 0x0040, 0x28c: 0x2000, 0x28d: 0x0040, 0x28e: 0x2000, 0x28f: 0x0040, 0x290: 0x0040, 0x291: 0x0040, 0x292: 0x0040, 0x293: 0x0040, 0x294: 0x0040, 0x295: 0x0040, 0x296: 0x0040, 0x297: 0x0040, 0x298: 0x0040, 0x299: 0x0040, 0x29a: 0x0040, 0x29b: 0x0040, 0x29c: 0x0040, 0x29d: 0x0040, 0x29e: 0x0040, 0x29f: 0x0040, 0x2a0: 0x0040, 0x2a1: 0x0040, 0x2a2: 0x0040, 0x2a3: 0x0040, 0x2a4: 0x0040, 0x2a5: 0x0040, 0x2a6: 0x0040, 0x2a7: 0x0040, 0x2a8: 0x0040, 0x2a9: 0x0040, 0x2aa: 0x0040, 0x2ab: 0x0040, 0x2ac: 0x0040, 0x2ad: 0x0040, 0x2ae: 0x0040, 0x2af: 0x0040, 0x2b0: 0x0040, 0x2b1: 0x0040, 0x2b2: 0x0040, 0x2b3: 0x0040, 0x2b4: 0x0040, 0x2b5: 0x0040, 0x2b6: 0x0040, 0x2b7: 0x0040, 0x2b8: 0x0040, 0x2b9: 0x0040, 0x2ba: 0x0040, 0x2bb: 0x0040, 0x2bc: 0x0040, 0x2bd: 0x0040, 0x2be: 0x0040, 0x2bf: 0x0040, // Block 0xb, offset 0x2c0 0x2c0: 0x0040, 0x2c1: 0x0040, 0x2c2: 0x0040, 0x2c3: 0x0040, 0x2c4: 0x0040, 0x2c5: 0x0040, 0x2c6: 0x0040, 0x2c7: 0x0040, 0x2c8: 0x0040, 0x2c9: 0x0040, 0x2ca: 0x0040, 0x2cb: 0x0040, 0x2cc: 0x0040, 0x2cd: 0x0040, 0x2ce: 0x0040, 0x2cf: 0x0040, 0x2d0: 0x0040, 0x2d1: 0x0040, 0x2d2: 0x0040, 0x2d3: 0x0040, 0x2d4: 0x0100, 0x2d5: 0x0100, 0x2d6: 0x0040, 0x2d7: 0x0040, 0x2d8: 0x0040, 0x2d9: 0x0040, 0x2da: 0x0040, 0x2db: 0x0040, 0x2dc: 0x0040, 0x2dd: 0x0040, 0x2de: 0x0040, 0x2df: 0x0040, 0x2e0: 0x0040, 0x2e1: 0x0040, 0x2e2: 0x0040, 0x2e3: 0x0040, 0x2e4: 0x0040, 0x2e5: 0x0040, 0x2e6: 0x0040, 0x2e7: 0x0040, 0x2e8: 0x0040, 0x2e9: 0x0040, 0x2ea: 0x0040, 0x2eb: 0x0040, 0x2ec: 0x0040, 0x2ed: 0x0040, 0x2ee: 0x0040, 0x2ef: 0x0040, 0x2f0: 0x0040, 0x2f1: 0x0040, 0x2f2: 0x0040, 0x2f3: 0x0040, 0x2f4: 0x0040, 0x2f5: 0x0040, 0x2f6: 0x0040, 0x2f7: 0x0040, 0x2f8: 0x0040, 0x2f9: 0x0100, 0x2fa: 0x0100, 0x2fb: 0x0100, 0x2fc: 0x0100, 0x2fd: 0x0100, 0x2fe: 0x0100, 0x2ff: 0x0100, // Block 0xc, offset 0x300 0x300: 0x0040, 0x301: 0x0040, 0x306: 0x0100, 0x307: 0x0100, 0x308: 0x0100, 0x309: 0x0100, 0x30a: 0x0100, 0x30b: 0x0100, 0x30c: 0x0100, 0x30d: 0x0100, 0x30e: 0x0100, 0x30f: 0x0100, 0x310: 0x0100, 0x311: 0x0100, 0x320: 0x0040, 0x321: 0x0040, 0x322: 0x0040, 0x323: 0x0040, 0x324: 0x0040, 0x32c: 0x0100, 0x32e: 0x0100, // Block 0xd, offset 0x340 0x340: 0x0008, 0x341: 0x0008, 0x342: 0x0008, 0x343: 0x0008, 0x344: 0x0008, 0x345: 0x0008, 0x346: 0x0008, 0x347: 0x0008, 0x348: 0x0008, 0x349: 0x0008, 0x34a: 0x0008, 0x34b: 0x0008, 0x34c: 0x0008, 0x34d: 0x0008, 0x34e: 0x0008, 0x34f: 0x0008, 0x350: 0x0008, 0x351: 0x0008, 0x352: 0x0008, 0x353: 0x0008, 0x354: 0x0008, 0x355: 0x0008, 0x356: 0x0008, 0x357: 0x0008, 0x358: 0x0008, 0x359: 0x0008, 0x35a: 0x0008, 0x35b: 0x0008, 0x35c: 0x0008, 0x35d: 0x0008, 0x35e: 0x0008, 0x35f: 0x0008, 0x360: 0x0008, 0x361: 0x0008, 0x362: 0x0008, 0x363: 0x0008, 0x364: 0x0008, 0x365: 0x0008, 0x366: 0x0008, 0x367: 0x0008, 0x368: 0x0008, 0x369: 0x0008, 0x36a: 0x0008, 0x36b: 0x0008, 0x36c: 0x0008, 0x36d: 0x0008, 0x36e: 0x0008, 0x36f: 0x0008, 0x370: 0x0008, 0x371: 0x0008, 0x372: 0x0008, 0x373: 0x0008, 0x374: 0x0008, 0x375: 0x0008, 0x376: 0x0008, 0x377: 0x0008, 0x378: 0x0008, 0x379: 0x0008, 0x37a: 0x0008, 0x37b: 0x0008, 0x37c: 0x0008, 0x37d: 0x0008, 0x37e: 0x0008, 0x37f: 0x0008, // Block 0xe, offset 0x380 0x380: 0x0008, 0x381: 0x0008, 0x382: 0x0008, 0x383: 0x0008, 0x384: 0x0008, 0x385: 0x0008, 0x386: 0x0008, 0x387: 0x0008, 0x388: 0x0008, 0x389: 0x0008, 0x38a: 0x0008, 0x38b: 0x0008, 0x38c: 0x0008, 0x38d: 0x0008, 0x38e: 0x0008, 0x38f: 0x0008, 0x390: 0x0008, 0x391: 0x0008, 0x392: 0x0008, 0x393: 0x0008, 0x394: 0x0008, 0x395: 0x0008, 0x396: 0x0008, 0x397: 0x0008, 0x398: 0x0008, 0x399: 0x0008, 0x39a: 0x0008, 0x39b: 0x0008, 0x39c: 0x0008, 0x39d: 0x0008, 0x39e: 0x0008, 0x39f: 0x0008, 0x3a0: 0x0008, 0x3a1: 0x0008, 0x3a2: 0x0008, 0x3a3: 0x0008, 0x3a4: 0x0008, 0x3a5: 0x0008, 0x3a6: 0x0008, 0x3a7: 0x0008, 0x3a8: 0x0008, 0x3a9: 0x0008, 0x3aa: 0x0008, 0x3ab: 0x0008, 0x3ac: 0x0008, 0x3ad: 0x0008, 0x3ae: 0x0008, 0x3af: 0x0008, 0x3b0: 0x2000, 0x3b1: 0x0040, 0x3b2: 0x2000, 0x3b3: 0x0040, 0x3b4: 0x0100, 0x3b6: 0x2000, 0x3b7: 0x0040, 0x3ba: 0x0040, 0x3bb: 0x0040, 0x3bc: 0x0040, 0x3bd: 0x0040, 0x3be: 0x0200, 0x3bf: 0x2000, // Block 0xf, offset 0x3c0 0x3c6: 0x2000, 0x3c8: 0x2000, 0x3c9: 0x2000, 0x3ca: 0x2000, 0x3cc: 0x2000, 0x3ce: 0x2000, 0x3cf: 0x2000, 0x3d0: 0x0040, 0x3d1: 0x2000, 0x3d2: 0x2000, 0x3d3: 0x2000, 0x3d4: 0x2000, 0x3d5: 0x2000, 0x3d6: 0x2000, 0x3d7: 0x2000, 0x3d8: 0x2000, 0x3d9: 0x2000, 0x3da: 0x2000, 0x3db: 0x2000, 0x3dc: 0x2000, 0x3dd: 0x2000, 0x3de: 0x2000, 0x3df: 0x2000, 0x3e0: 0x2000, 0x3e1: 0x2000, 0x3e3: 0x2000, 0x3e4: 0x2000, 0x3e5: 0x2000, 0x3e6: 0x2000, 0x3e7: 0x2000, 0x3e8: 0x2000, 0x3e9: 0x2000, 0x3ea: 0x2000, 0x3eb: 0x2000, 0x3ec: 0x0040, 0x3ed: 0x0040, 0x3ee: 0x0040, 0x3ef: 0x0040, 0x3f0: 0x0040, 0x3f1: 0x0040, 0x3f2: 0x0040, 0x3f3: 0x0040, 0x3f4: 0x0040, 0x3f5: 0x0040, 0x3f6: 0x0040, 0x3f7: 0x0040, 0x3f8: 0x0040, 0x3f9: 0x0040, 0x3fa: 0x0040, 0x3fb: 0x0040, 0x3fc: 0x0040, 0x3fd: 0x0040, 0x3fe: 0x0040, 0x3ff: 0x0040, // Block 0x10, offset 0x400 0x400: 0x0040, 0x401: 0x0040, 0x402: 0x0040, 0x403: 0x0040, 0x404: 0x0040, 0x405: 0x0040, 0x406: 0x0040, 0x407: 0x0040, 0x408: 0x0040, 0x409: 0x0040, 0x40a: 0x0040, 0x40b: 0x0040, 0x40c: 0x0040, 0x40d: 0x0040, 0x40e: 0x0040, 0x40f: 0x2000, 0x410: 0x0040, 0x411: 0x0040, 0x412: 0x2000, 0x413: 0x2000, 0x414: 0x2000, 0x415: 0x0040, 0x416: 0x0040, 0x417: 0x0040, 0x418: 0x2000, 0x419: 0x0040, 0x41a: 0x2000, 0x41b: 0x0040, 0x41c: 0x2000, 0x41d: 0x0040, 0x41e: 0x2000, 0x41f: 0x0040, 0x420: 0x2000, 0x421: 0x0040, 0x422: 0x2000, 0x423: 0x0040, 0x424: 0x2000, 0x425: 0x0040, 0x426: 0x2000, 0x427: 0x0040, 0x428: 0x2000, 0x429: 0x0040, 0x42a: 0x2000, 0x42b: 0x0040, 0x42c: 0x2000, 0x42d: 0x0040, 0x42e: 0x2000, 0x42f: 0x0040, 0x430: 0x0040, 0x431: 0x0040, 0x432: 0x0040, 0x433: 0x0040, 0x434: 0x2000, 0x435: 0x0040, 0x437: 0x2000, 0x438: 0x0040, 0x439: 0x2000, 0x43a: 0x2000, 0x43b: 0x0040, 0x43c: 0x0040, 0x43d: 0x2000, 0x43e: 0x2000, 0x43f: 0x2000, // Block 0x11, offset 0x440 0x440: 0x2000, 0x441: 0x2000, 0x442: 0x2000, 0x443: 0x2000, 0x444: 0x2000, 0x445: 0x2000, 0x446: 0x2000, 0x447: 0x2000, 0x448: 0x2000, 0x449: 0x2000, 0x44a: 0x2000, 0x44b: 0x2000, 0x44c: 0x2000, 0x44d: 0x2000, 0x44e: 0x2000, 0x44f: 0x2000, 0x450: 0x2000, 0x451: 0x2000, 0x452: 0x2000, 0x453: 0x2000, 0x454: 0x2000, 0x455: 0x2000, 0x456: 0x2000, 0x457: 0x2000, 0x458: 0x2000, 0x459: 0x2000, 0x45a: 0x2000, 0x45b: 0x2000, 0x45c: 0x2000, 0x45d: 0x2000, 0x45e: 0x2000, 0x45f: 0x2000, 0x460: 0x2000, 0x461: 0x2000, 0x462: 0x2000, 0x463: 0x2000, 0x464: 0x2000, 0x465: 0x2000, 0x466: 0x2000, 0x467: 0x2000, 0x468: 0x2000, 0x469: 0x2000, 0x46a: 0x2000, 0x46b: 0x2000, 0x46c: 0x2000, 0x46d: 0x2000, 0x46e: 0x2000, 0x46f: 0x2000, 0x470: 0x0040, 0x471: 0x0040, 0x472: 0x0040, 0x473: 0x0040, 0x474: 0x0040, 0x475: 0x0040, 0x476: 0x0040, 0x477: 0x0040, 0x478: 0x0040, 0x479: 0x0040, 0x47a: 0x0040, 0x47b: 0x0040, 0x47c: 0x0040, 0x47d: 0x0040, 0x47e: 0x0040, 0x47f: 0x0040, // Block 0x12, offset 0x480 0x480: 0x0040, 0x481: 0x0040, 0x482: 0x0040, 0x483: 0x0040, 0x484: 0x0040, 0x485: 0x0040, 0x486: 0x0040, 0x487: 0x0040, 0x488: 0x0040, 0x489: 0x0040, 0x48a: 0x0040, 0x48b: 0x0040, 0x48c: 0x0040, 0x48d: 0x0040, 0x48e: 0x0040, 0x48f: 0x0040, 0x490: 0x0040, 0x491: 0x0040, 0x492: 0x0040, 0x493: 0x0040, 0x494: 0x0040, 0x495: 0x0040, 0x496: 0x0040, 0x497: 0x0040, 0x498: 0x0040, 0x499: 0x0040, 0x49a: 0x0040, 0x49b: 0x0040, 0x49c: 0x0040, 0x49d: 0x0040, 0x49e: 0x0040, 0x49f: 0x0040, 0x4a0: 0x2000, 0x4a1: 0x0040, 0x4a2: 0x2000, 0x4a3: 0x0040, 0x4a4: 0x2000, 0x4a5: 0x0040, 0x4a6: 0x2000, 0x4a7: 0x0040, 0x4a8: 0x2000, 0x4a9: 0x0040, 0x4aa: 0x2000, 0x4ab: 0x0040, 0x4ac: 0x2000, 0x4ad: 0x0040, 0x4ae: 0x2000, 0x4af: 0x0040, 0x4b0: 0x2000, 0x4b1: 0x0040, 0x4b2: 0x2000, 0x4b3: 0x0040, 0x4b4: 0x2000, 0x4b5: 0x0040, 0x4b6: 0x2000, 0x4b7: 0x0040, 0x4b8: 0x2000, 0x4b9: 0x0040, 0x4ba: 0x2000, 0x4bb: 0x0040, 0x4bc: 0x2000, 0x4bd: 0x0040, 0x4be: 0x2000, 0x4bf: 0x0040, // Block 0x13, offset 0x4c0 0x4c0: 0x2000, 0x4c1: 0x0040, 0x4c3: 0x0008, 0x4c4: 0x0008, 0x4c5: 0x0008, 0x4c6: 0x0008, 0x4c7: 0x0008, 0x4c8: 0x0008, 0x4c9: 0x0008, 0x4ca: 0x2000, 0x4cb: 0x0040, 0x4cc: 0x2000, 0x4cd: 0x0040, 0x4ce: 0x2000, 0x4cf: 0x0040, 0x4d0: 0x2000, 0x4d1: 0x0040, 0x4d2: 0x2000, 0x4d3: 0x0040, 0x4d4: 0x2000, 0x4d5: 0x0040, 0x4d6: 0x2000, 0x4d7: 0x0040, 0x4d8: 0x2000, 0x4d9: 0x0040, 0x4da: 0x2000, 0x4db: 0x0040, 0x4dc: 0x2000, 0x4dd: 0x0040, 0x4de: 0x2000, 0x4df: 0x0040, 0x4e0: 0x2000, 0x4e1: 0x0040, 0x4e2: 0x2000, 0x4e3: 0x0040, 0x4e4: 0x2000, 0x4e5: 0x0040, 0x4e6: 0x2000, 0x4e7: 0x0040, 0x4e8: 0x2000, 0x4e9: 0x0040, 0x4ea: 0x2000, 0x4eb: 0x0040, 0x4ec: 0x2000, 0x4ed: 0x0040, 0x4ee: 0x2000, 0x4ef: 0x0040, 0x4f0: 0x2000, 0x4f1: 0x0040, 0x4f2: 0x2000, 0x4f3: 0x0040, 0x4f4: 0x2000, 0x4f5: 0x0040, 0x4f6: 0x2000, 0x4f7: 0x0040, 0x4f8: 0x2000, 0x4f9: 0x0040, 0x4fa: 0x2000, 0x4fb: 0x0040, 0x4fc: 0x2000, 0x4fd: 0x0040, 0x4fe: 0x2000, 0x4ff: 0x0040, // Block 0x14, offset 0x500 0x500: 0x2000, 0x501: 0x2000, 0x502: 0x0040, 0x503: 0x2000, 0x504: 0x0040, 0x505: 0x2000, 0x506: 0x0040, 0x507: 0x2000, 0x508: 0x0040, 0x509: 0x2000, 0x50a: 0x0040, 0x50b: 0x2000, 0x50c: 0x0040, 0x50d: 0x2000, 0x50e: 0x0040, 0x50f: 0x0040, 0x510: 0x2000, 0x511: 0x0040, 0x512: 0x2000, 0x513: 0x0040, 0x514: 0x2000, 0x515: 0x0040, 0x516: 0x2000, 0x517: 0x0040, 0x518: 0x2000, 0x519: 0x0040, 0x51a: 0x2000, 0x51b: 0x0040, 0x51c: 0x2000, 0x51d: 0x0040, 0x51e: 0x2000, 0x51f: 0x0040, 0x520: 0x2000, 0x521: 0x0040, 0x522: 0x2000, 0x523: 0x0040, 0x524: 0x2000, 0x525: 0x0040, 0x526: 0x2000, 0x527: 0x0040, 0x528: 0x2000, 0x529: 0x0040, 0x52a: 0x2000, 0x52b: 0x0040, 0x52c: 0x2000, 0x52d: 0x0040, 0x52e: 0x2000, 0x52f: 0x0040, 0x530: 0x2000, 0x531: 0x0040, 0x532: 0x2000, 0x533: 0x0040, 0x534: 0x2000, 0x535: 0x0040, 0x536: 0x2000, 0x537: 0x0040, 0x538: 0x2000, 0x539: 0x0040, 0x53a: 0x2000, 0x53b: 0x0040, 0x53c: 0x2000, 0x53d: 0x0040, 0x53e: 0x2000, 0x53f: 0x0040, // Block 0x15, offset 0x540 0x540: 0x2000, 0x541: 0x0040, 0x542: 0x2000, 0x543: 0x0040, 0x544: 0x2000, 0x545: 0x0040, 0x546: 0x2000, 0x547: 0x0040, 0x548: 0x2000, 0x549: 0x0040, 0x54a: 0x2000, 0x54b: 0x0040, 0x54c: 0x2000, 0x54d: 0x0040, 0x54e: 0x2000, 0x54f: 0x0040, 0x550: 0x2000, 0x551: 0x0040, 0x552: 0x2000, 0x553: 0x0040, 0x554: 0x2000, 0x555: 0x0040, 0x556: 0x2000, 0x557: 0x0040, 0x558: 0x2000, 0x559: 0x0040, 0x55a: 0x2000, 0x55b: 0x0040, 0x55c: 0x2000, 0x55d: 0x0040, 0x55e: 0x2000, 0x55f: 0x0040, 0x560: 0x2000, 0x561: 0x0040, 0x562: 0x2000, 0x563: 0x0040, 0x564: 0x2000, 0x565: 0x0040, 0x566: 0x2000, 0x567: 0x0040, 0x568: 0x2000, 0x569: 0x0040, 0x56a: 0x2000, 0x56b: 0x0040, 0x56c: 0x2000, 0x56d: 0x0040, 0x56e: 0x2000, 0x56f: 0x0040, 0x571: 0x2000, 0x572: 0x2000, 0x573: 0x2000, 0x574: 0x2000, 0x575: 0x2000, 0x576: 0x2000, 0x577: 0x2000, 0x578: 0x2000, 0x579: 0x2000, 0x57a: 0x2000, 0x57b: 0x2000, 0x57c: 0x2000, 0x57d: 0x2000, 0x57e: 0x2000, 0x57f: 0x2000, // Block 0x16, offset 0x580 0x580: 0x2000, 0x581: 0x2000, 0x582: 0x2000, 0x583: 0x2000, 0x584: 0x2000, 0x585: 0x2000, 0x586: 0x2000, 0x587: 0x2000, 0x588: 0x2000, 0x589: 0x2000, 0x58a: 0x2000, 0x58b: 0x2000, 0x58c: 0x2000, 0x58d: 0x2000, 0x58e: 0x2000, 0x58f: 0x2000, 0x590: 0x2000, 0x591: 0x2000, 0x592: 0x2000, 0x593: 0x2000, 0x594: 0x2000, 0x595: 0x2000, 0x596: 0x2000, 0x599: 0x0100, 0x59d: 0x0200, 0x5a0: 0x0040, 0x5a1: 0x0040, 0x5a2: 0x0040, 0x5a3: 0x0040, 0x5a4: 0x0040, 0x5a5: 0x0040, 0x5a6: 0x0040, 0x5a7: 0x0040, 0x5a8: 0x0040, 0x5a9: 0x0040, 0x5aa: 0x0040, 0x5ab: 0x0040, 0x5ac: 0x0040, 0x5ad: 0x0040, 0x5ae: 0x0040, 0x5af: 0x0040, 0x5b0: 0x0040, 0x5b1: 0x0040, 0x5b2: 0x0040, 0x5b3: 0x0040, 0x5b4: 0x0040, 0x5b5: 0x0040, 0x5b6: 0x0040, 0x5b7: 0x0040, 0x5b8: 0x0040, 0x5b9: 0x0040, 0x5ba: 0x0040, 0x5bb: 0x0040, 0x5bc: 0x0040, 0x5bd: 0x0040, 0x5be: 0x0040, 0x5bf: 0x0040, // Block 0x17, offset 0x5c0 0x5c0: 0x0040, 0x5c1: 0x0040, 0x5c2: 0x0040, 0x5c3: 0x0040, 0x5c4: 0x0040, 0x5c5: 0x0040, 0x5c6: 0x0040, 0x5c7: 0x0040, 0x5c8: 0x0040, 0x5c9: 0x0400, 0x5d1: 0x0008, 0x5d2: 0x0008, 0x5d3: 0x0008, 0x5d4: 0x0008, 0x5d5: 0x0008, 0x5d6: 0x0008, 0x5d7: 0x0008, 0x5d8: 0x0008, 0x5d9: 0x0008, 0x5da: 0x0008, 0x5db: 0x0008, 0x5dc: 0x0008, 0x5dd: 0x0008, 0x5de: 0x0008, 0x5df: 0x0008, 0x5e0: 0x0008, 0x5e1: 0x0008, 0x5e2: 0x0008, 0x5e3: 0x0008, 0x5e4: 0x0008, 0x5e5: 0x0008, 0x5e6: 0x0008, 0x5e7: 0x0008, 0x5e8: 0x0008, 0x5e9: 0x0008, 0x5ea: 0x0008, 0x5eb: 0x0008, 0x5ec: 0x0008, 0x5ed: 0x0008, 0x5ee: 0x0008, 0x5ef: 0x0008, 0x5f0: 0x0008, 0x5f1: 0x0008, 0x5f2: 0x0008, 0x5f3: 0x0008, 0x5f4: 0x0008, 0x5f5: 0x0008, 0x5f6: 0x0008, 0x5f7: 0x0008, 0x5f8: 0x0008, 0x5f9: 0x0008, 0x5fa: 0x0008, 0x5fb: 0x0008, 0x5fc: 0x0008, 0x5fd: 0x0008, 0x5ff: 0x0008, // Block 0x18, offset 0x600 0x601: 0x0008, 0x602: 0x0008, 0x604: 0x0008, 0x605: 0x0008, 0x607: 0x0008, 0x610: 0x0100, 0x611: 0x0100, 0x612: 0x0100, 0x613: 0x0100, 0x614: 0x0100, 0x615: 0x0100, 0x616: 0x0100, 0x617: 0x0100, 0x618: 0x0100, 0x619: 0x0100, 0x61a: 0x0100, 0x61b: 0x0100, 0x61c: 0x0100, 0x61d: 0x0100, 0x61e: 0x0100, 0x61f: 0x0100, 0x620: 0x0100, 0x621: 0x0100, 0x622: 0x0100, 0x623: 0x0100, 0x624: 0x0100, 0x625: 0x0100, 0x626: 0x0100, 0x627: 0x0100, 0x628: 0x0100, 0x629: 0x0100, 0x62a: 0x0100, 0x62f: 0x0100, 0x630: 0x0100, 0x631: 0x0100, 0x632: 0x0100, 0x633: 0x0100, // Block 0x19, offset 0x640 0x640: 0x0080, 0x641: 0x0080, 0x642: 0x0080, 0x643: 0x0080, 0x644: 0x0080, 0x645: 0x0080, 0x64c: 0x0200, 0x64d: 0x0200, 0x650: 0x0008, 0x651: 0x0008, 0x652: 0x0008, 0x653: 0x0008, 0x654: 0x0008, 0x655: 0x0008, 0x656: 0x0008, 0x657: 0x0008, 0x658: 0x0008, 0x659: 0x0008, 0x65a: 0x0008, 0x65c: 0x0010, 0x65d: 0x0400, 0x65e: 0x0400, 0x65f: 0x0400, 0x660: 0x0100, 0x661: 0x0100, 0x662: 0x0100, 0x663: 0x0100, 0x664: 0x0100, 0x665: 0x0100, 0x666: 0x0100, 0x667: 0x0100, 0x668: 0x0100, 0x669: 0x0100, 0x66a: 0x0100, 0x66b: 0x0100, 0x66c: 0x0100, 0x66d: 0x0100, 0x66e: 0x0100, 0x66f: 0x0100, 0x670: 0x0100, 0x671: 0x0100, 0x672: 0x0100, 0x673: 0x0100, 0x674: 0x0100, 0x675: 0x0100, 0x676: 0x0100, 0x677: 0x0100, 0x678: 0x0100, 0x679: 0x0100, 0x67a: 0x0100, 0x67b: 0x0100, 0x67c: 0x0100, 0x67d: 0x0100, 0x67e: 0x0100, 0x67f: 0x0100, // Block 0x1a, offset 0x680 0x680: 0x0100, 0x681: 0x0100, 0x682: 0x0100, 0x683: 0x0100, 0x684: 0x0100, 0x685: 0x0100, 0x686: 0x0100, 0x687: 0x0100, 0x688: 0x0100, 0x689: 0x0100, 0x68a: 0x0100, 0x68b: 0x0008, 0x68c: 0x0008, 0x68d: 0x0008, 0x68e: 0x0008, 0x68f: 0x0008, 0x690: 0x0008, 0x691: 0x0008, 0x692: 0x0008, 0x693: 0x0008, 0x694: 0x0008, 0x695: 0x0008, 0x696: 0x0008, 0x697: 0x0008, 0x698: 0x0008, 0x699: 0x0008, 0x69a: 0x0008, 0x69b: 0x0008, 0x69c: 0x0008, 0x69d: 0x0008, 0x69e: 0x0008, 0x69f: 0x0008, 0x6a0: 0x0080, 0x6a1: 0x0080, 0x6a2: 0x0080, 0x6a3: 0x0080, 0x6a4: 0x0080, 0x6a5: 0x0080, 0x6a6: 0x0080, 0x6a7: 0x0080, 0x6a8: 0x0080, 0x6a9: 0x0080, 0x6ab: 0x0080, 0x6ac: 0x0080, 0x6ae: 0x0100, 0x6af: 0x0100, 0x6b0: 0x0008, 0x6b1: 0x0100, 0x6b2: 0x0100, 0x6b3: 0x0100, 0x6b4: 0x0100, 0x6b5: 0x0100, 0x6b6: 0x0100, 0x6b7: 0x0100, 0x6b8: 0x0100, 0x6b9: 0x0100, 0x6ba: 0x0100, 0x6bb: 0x0100, 0x6bc: 0x0100, 0x6bd: 0x0100, 0x6be: 0x0100, 0x6bf: 0x0100, // Block 0x1b, offset 0x6c0 0x6c0: 0x0100, 0x6c1: 0x0100, 0x6c2: 0x0100, 0x6c3: 0x0100, 0x6c4: 0x0100, 0x6c5: 0x0100, 0x6c6: 0x0100, 0x6c7: 0x0100, 0x6c8: 0x0100, 0x6c9: 0x0100, 0x6ca: 0x0100, 0x6cb: 0x0100, 0x6cc: 0x0100, 0x6cd: 0x0100, 0x6ce: 0x0100, 0x6cf: 0x0100, 0x6d0: 0x0100, 0x6d1: 0x0100, 0x6d2: 0x0100, 0x6d3: 0x0100, 0x6d4: 0x0100, 0x6d5: 0x0100, 0x6d6: 0x0100, 0x6d7: 0x0100, 0x6d8: 0x0100, 0x6d9: 0x0100, 0x6da: 0x0100, 0x6db: 0x0100, 0x6dc: 0x0100, 0x6dd: 0x0100, 0x6de: 0x0100, 0x6df: 0x0100, 0x6e0: 0x0100, 0x6e1: 0x0100, 0x6e2: 0x0100, 0x6e3: 0x0100, 0x6e4: 0x0100, 0x6e5: 0x0100, 0x6e6: 0x0100, 0x6e7: 0x0100, 0x6e8: 0x0100, 0x6e9: 0x0100, 0x6ea: 0x0100, 0x6eb: 0x0100, 0x6ec: 0x0100, 0x6ed: 0x0100, 0x6ee: 0x0100, 0x6ef: 0x0100, 0x6f0: 0x0100, 0x6f1: 0x0100, 0x6f2: 0x0100, 0x6f3: 0x0100, 0x6f4: 0x0100, 0x6f5: 0x0100, 0x6f6: 0x0100, 0x6f7: 0x0100, 0x6f8: 0x0100, 0x6f9: 0x0100, 0x6fa: 0x0100, 0x6fb: 0x0100, 0x6fc: 0x0100, 0x6fd: 0x0100, 0x6fe: 0x0100, 0x6ff: 0x0100, // Block 0x1c, offset 0x700 0x700: 0x0100, 0x701: 0x0100, 0x702: 0x0100, 0x703: 0x0100, 0x704: 0x0100, 0x705: 0x0100, 0x706: 0x0100, 0x707: 0x0100, 0x708: 0x0100, 0x709: 0x0100, 0x70a: 0x0100, 0x70b: 0x0100, 0x70c: 0x0100, 0x70d: 0x0100, 0x70e: 0x0100, 0x70f: 0x0100, 0x710: 0x0100, 0x711: 0x0100, 0x712: 0x0100, 0x713: 0x0100, 0x714: 0x0400, 0x715: 0x0100, 0x716: 0x0008, 0x717: 0x0008, 0x718: 0x0008, 0x719: 0x0008, 0x71a: 0x0008, 0x71b: 0x0008, 0x71c: 0x0008, 0x71d: 0x0080, 0x71f: 0x0008, 0x720: 0x0008, 0x721: 0x0008, 0x722: 0x0008, 0x723: 0x0008, 0x724: 0x0008, 0x725: 0x0100, 0x726: 0x0100, 0x727: 0x0008, 0x728: 0x0008, 0x72a: 0x0008, 0x72b: 0x0008, 0x72c: 0x0008, 0x72d: 0x0008, 0x72e: 0x0100, 0x72f: 0x0100, 0x730: 0x0080, 0x731: 0x0080, 0x732: 0x0080, 0x733: 0x0080, 0x734: 0x0080, 0x735: 0x0080, 0x736: 0x0080, 0x737: 0x0080, 0x738: 0x0080, 0x739: 0x0080, 0x73a: 0x0100, 0x73b: 0x0100, 0x73c: 0x0100, 0x73f: 0x0100, // Block 0x1d, offset 0x740 0x740: 0x0400, 0x741: 0x0400, 0x742: 0x0400, 0x74f: 0x0010, 0x750: 0x0100, 0x751: 0x0008, 0x752: 0x0100, 0x753: 0x0100, 0x754: 0x0100, 0x755: 0x0100, 0x756: 0x0100, 0x757: 0x0100, 0x758: 0x0100, 0x759: 0x0100, 0x75a: 0x0100, 0x75b: 0x0100, 0x75c: 0x0100, 0x75d: 0x0100, 0x75e: 0x0100, 0x75f: 0x0100, 0x760: 0x0100, 0x761: 0x0100, 0x762: 0x0100, 0x763: 0x0100, 0x764: 0x0100, 0x765: 0x0100, 0x766: 0x0100, 0x767: 0x0100, 0x768: 0x0100, 0x769: 0x0100, 0x76a: 0x0100, 0x76b: 0x0100, 0x76c: 0x0100, 0x76d: 0x0100, 0x76e: 0x0100, 0x76f: 0x0100, 0x770: 0x0008, 0x771: 0x0008, 0x772: 0x0008, 0x773: 0x0008, 0x774: 0x0008, 0x775: 0x0008, 0x776: 0x0008, 0x777: 0x0008, 0x778: 0x0008, 0x779: 0x0008, 0x77a: 0x0008, 0x77b: 0x0008, 0x77c: 0x0008, 0x77d: 0x0008, 0x77e: 0x0008, 0x77f: 0x0008, // Block 0x1e, offset 0x780 0x780: 0x0008, 0x781: 0x0008, 0x782: 0x0008, 0x783: 0x0008, 0x784: 0x0008, 0x785: 0x0008, 0x786: 0x0008, 0x787: 0x0008, 0x788: 0x0008, 0x789: 0x0008, 0x78a: 0x0008, 0x78d: 0x0100, 0x78e: 0x0100, 0x78f: 0x0100, 0x790: 0x0100, 0x791: 0x0100, 0x792: 0x0100, 0x793: 0x0100, 0x794: 0x0100, 0x795: 0x0100, 0x796: 0x0100, 0x797: 0x0100, 0x798: 0x0100, 0x799: 0x0100, 0x79a: 0x0100, 0x79b: 0x0100, 0x79c: 0x0100, 0x79d: 0x0100, 0x79e: 0x0100, 0x79f: 0x0100, 0x7a0: 0x0100, 0x7a1: 0x0100, 0x7a2: 0x0100, 0x7a3: 0x0100, 0x7a4: 0x0100, 0x7a5: 0x0100, 0x7a6: 0x0100, 0x7a7: 0x0100, 0x7a8: 0x0100, 0x7a9: 0x0100, 0x7aa: 0x0100, 0x7ab: 0x0100, 0x7ac: 0x0100, 0x7ad: 0x0100, 0x7ae: 0x0100, 0x7af: 0x0100, 0x7b0: 0x0100, 0x7b1: 0x0100, 0x7b2: 0x0100, 0x7b3: 0x0100, 0x7b4: 0x0100, 0x7b5: 0x0100, 0x7b6: 0x0100, 0x7b7: 0x0100, 0x7b8: 0x0100, 0x7b9: 0x0100, 0x7ba: 0x0100, 0x7bb: 0x0100, 0x7bc: 0x0100, 0x7bd: 0x0100, 0x7be: 0x0100, 0x7bf: 0x0100, // Block 0x1f, offset 0x7c0 0x7c0: 0x0100, 0x7c1: 0x0100, 0x7c2: 0x0100, 0x7c3: 0x0100, 0x7c4: 0x0100, 0x7c5: 0x0100, 0x7c6: 0x0100, 0x7c7: 0x0100, 0x7c8: 0x0100, 0x7c9: 0x0100, 0x7ca: 0x0100, 0x7cb: 0x0100, 0x7cc: 0x0100, 0x7cd: 0x0100, 0x7ce: 0x0100, 0x7cf: 0x0100, 0x7d0: 0x0100, 0x7d1: 0x0100, 0x7d2: 0x0100, 0x7d3: 0x0100, 0x7d4: 0x0100, 0x7d5: 0x0100, 0x7d6: 0x0100, 0x7d7: 0x0100, 0x7d8: 0x0100, 0x7d9: 0x0100, 0x7da: 0x0100, 0x7db: 0x0100, 0x7dc: 0x0100, 0x7dd: 0x0100, 0x7de: 0x0100, 0x7df: 0x0100, 0x7e0: 0x0100, 0x7e1: 0x0100, 0x7e2: 0x0100, 0x7e3: 0x0100, 0x7e4: 0x0100, 0x7e5: 0x0100, 0x7e6: 0x0008, 0x7e7: 0x0008, 0x7e8: 0x0008, 0x7e9: 0x0008, 0x7ea: 0x0008, 0x7eb: 0x0008, 0x7ec: 0x0008, 0x7ed: 0x0008, 0x7ee: 0x0008, 0x7ef: 0x0008, 0x7f0: 0x0008, 0x7f1: 0x0100, // Block 0x20, offset 0x800 0x800: 0x0080, 0x801: 0x0080, 0x802: 0x0080, 0x803: 0x0080, 0x804: 0x0080, 0x805: 0x0080, 0x806: 0x0080, 0x807: 0x0080, 0x808: 0x0080, 0x809: 0x0080, 0x80a: 0x0100, 0x80b: 0x0100, 0x80c: 0x0100, 0x80d: 0x0100, 0x80e: 0x0100, 0x80f: 0x0100, 0x810: 0x0100, 0x811: 0x0100, 0x812: 0x0100, 0x813: 0x0100, 0x814: 0x0100, 0x815: 0x0100, 0x816: 0x0100, 0x817: 0x0100, 0x818: 0x0100, 0x819: 0x0100, 0x81a: 0x0100, 0x81b: 0x0100, 0x81c: 0x0100, 0x81d: 0x0100, 0x81e: 0x0100, 0x81f: 0x0100, 0x820: 0x0100, 0x821: 0x0100, 0x822: 0x0100, 0x823: 0x0100, 0x824: 0x0100, 0x825: 0x0100, 0x826: 0x0100, 0x827: 0x0100, 0x828: 0x0100, 0x829: 0x0100, 0x82a: 0x0100, 0x82b: 0x0008, 0x82c: 0x0008, 0x82d: 0x0008, 0x82e: 0x0008, 0x82f: 0x0008, 0x830: 0x0008, 0x831: 0x0008, 0x832: 0x0008, 0x833: 0x0008, 0x834: 0x0100, 0x835: 0x0100, 0x838: 0x0200, 0x839: 0x0400, 0x83a: 0x0100, 0x83d: 0x0008, // Block 0x21, offset 0x840 0x840: 0x0100, 0x841: 0x0100, 0x842: 0x0100, 0x843: 0x0100, 0x844: 0x0100, 0x845: 0x0100, 0x846: 0x0100, 0x847: 0x0100, 0x848: 0x0100, 0x849: 0x0100, 0x84a: 0x0100, 0x84b: 0x0100, 0x84c: 0x0100, 0x84d: 0x0100, 0x84e: 0x0100, 0x84f: 0x0100, 0x850: 0x0100, 0x851: 0x0100, 0x852: 0x0100, 0x853: 0x0100, 0x854: 0x0100, 0x855: 0x0100, 0x856: 0x0008, 0x857: 0x0008, 0x858: 0x0008, 0x859: 0x0008, 0x85a: 0x0100, 0x85b: 0x0008, 0x85c: 0x0008, 0x85d: 0x0008, 0x85e: 0x0008, 0x85f: 0x0008, 0x860: 0x0008, 0x861: 0x0008, 0x862: 0x0008, 0x863: 0x0008, 0x864: 0x0100, 0x865: 0x0008, 0x866: 0x0008, 0x867: 0x0008, 0x868: 0x0100, 0x869: 0x0008, 0x86a: 0x0008, 0x86b: 0x0008, 0x86c: 0x0008, 0x86d: 0x0008, 0x877: 0x0400, 0x879: 0x0400, 0x87d: 0x0400, 0x87e: 0x0400, // Block 0x22, offset 0x880 0x880: 0x0100, 0x881: 0x0100, 0x882: 0x0100, 0x883: 0x0100, 0x884: 0x0100, 0x885: 0x0100, 0x886: 0x0100, 0x887: 0x0100, 0x888: 0x0100, 0x889: 0x0100, 0x88a: 0x0100, 0x88b: 0x0100, 0x88c: 0x0100, 0x88d: 0x0100, 0x88e: 0x0100, 0x88f: 0x0100, 0x890: 0x0100, 0x891: 0x0100, 0x892: 0x0100, 0x893: 0x0100, 0x894: 0x0100, 0x895: 0x0100, 0x896: 0x0100, 0x897: 0x0100, 0x898: 0x0100, 0x899: 0x0008, 0x89a: 0x0008, 0x89b: 0x0008, 0x8a0: 0x0100, 0x8a1: 0x0100, 0x8a2: 0x0100, 0x8a3: 0x0100, 0x8a4: 0x0100, 0x8a5: 0x0100, 0x8a6: 0x0100, 0x8a7: 0x0100, 0x8a8: 0x0100, 0x8a9: 0x0100, 0x8aa: 0x0100, 0x8b0: 0x0100, 0x8b1: 0x0100, 0x8b2: 0x0100, 0x8b3: 0x0100, 0x8b4: 0x0100, 0x8b5: 0x0100, 0x8b6: 0x0100, 0x8b7: 0x0100, 0x8b8: 0x0100, 0x8b9: 0x0100, 0x8ba: 0x0100, 0x8bb: 0x0100, 0x8bc: 0x0100, 0x8bd: 0x0100, 0x8be: 0x0100, 0x8bf: 0x0100, // Block 0x23, offset 0x8c0 0x8c0: 0x0100, 0x8c1: 0x0100, 0x8c2: 0x0100, 0x8c3: 0x0100, 0x8c4: 0x0100, 0x8c5: 0x0100, 0x8c6: 0x0100, 0x8c7: 0x0100, 0x8c9: 0x0100, 0x8ca: 0x0100, 0x8cb: 0x0100, 0x8cc: 0x0100, 0x8cd: 0x0100, 0x8ce: 0x0100, 0x8cf: 0x0100, 0x8d0: 0x0080, 0x8d1: 0x0080, 0x8d7: 0x0008, 0x8d8: 0x0008, 0x8d9: 0x0008, 0x8da: 0x0008, 0x8db: 0x0008, 0x8dc: 0x0008, 0x8dd: 0x0008, 0x8de: 0x0008, 0x8df: 0x0008, 0x8e0: 0x0100, 0x8e1: 0x0100, 0x8e2: 0x0100, 0x8e3: 0x0100, 0x8e4: 0x0100, 0x8e5: 0x0100, 0x8e6: 0x0100, 0x8e7: 0x0100, 0x8e8: 0x0100, 0x8e9: 0x0100, 0x8ea: 0x0100, 0x8eb: 0x0100, 0x8ec: 0x0100, 0x8ed: 0x0100, 0x8ee: 0x0100, 0x8ef: 0x0100, 0x8f0: 0x0100, 0x8f1: 0x0100, 0x8f2: 0x0100, 0x8f3: 0x0100, 0x8f4: 0x0100, 0x8f5: 0x0100, 0x8f6: 0x0100, 0x8f7: 0x0100, 0x8f8: 0x0100, 0x8f9: 0x0100, 0x8fa: 0x0100, 0x8fb: 0x0100, 0x8fc: 0x0100, 0x8fd: 0x0100, 0x8fe: 0x0100, 0x8ff: 0x0100, // Block 0x24, offset 0x900 0x900: 0x0100, 0x901: 0x0100, 0x902: 0x0100, 0x903: 0x0100, 0x904: 0x0100, 0x905: 0x0100, 0x906: 0x0100, 0x907: 0x0100, 0x908: 0x0100, 0x909: 0x0100, 0x90a: 0x0008, 0x90b: 0x0008, 0x90c: 0x0008, 0x90d: 0x0008, 0x90e: 0x0008, 0x90f: 0x0008, 0x910: 0x0008, 0x911: 0x0008, 0x912: 0x0008, 0x913: 0x0008, 0x914: 0x0008, 0x915: 0x0008, 0x916: 0x0008, 0x917: 0x0008, 0x918: 0x0008, 0x919: 0x0008, 0x91a: 0x0008, 0x91b: 0x0008, 0x91c: 0x0008, 0x91d: 0x0008, 0x91e: 0x0008, 0x91f: 0x0008, 0x920: 0x0008, 0x921: 0x0008, 0x922: 0x0080, 0x923: 0x0008, 0x924: 0x0008, 0x925: 0x0008, 0x926: 0x0008, 0x927: 0x0008, 0x928: 0x0008, 0x929: 0x0008, 0x92a: 0x0008, 0x92b: 0x0008, 0x92c: 0x0008, 0x92d: 0x0008, 0x92e: 0x0008, 0x92f: 0x0008, 0x930: 0x0008, 0x931: 0x0008, 0x932: 0x0008, 0x933: 0x0008, 0x934: 0x0008, 0x935: 0x0008, 0x936: 0x0008, 0x937: 0x0008, 0x938: 0x0008, 0x939: 0x0008, 0x93a: 0x0008, 0x93b: 0x0008, 0x93c: 0x0008, 0x93d: 0x0008, 0x93e: 0x0008, 0x93f: 0x0008, // Block 0x25, offset 0x940 0x940: 0x0008, 0x941: 0x0008, 0x942: 0x0008, 0x943: 0x0008, 0x944: 0x0100, 0x945: 0x0100, 0x946: 0x0100, 0x947: 0x0100, 0x948: 0x0100, 0x949: 0x0100, 0x94a: 0x0100, 0x94b: 0x0100, 0x94c: 0x0100, 0x94d: 0x0100, 0x94e: 0x0100, 0x94f: 0x0100, 0x950: 0x0100, 0x951: 0x0100, 0x952: 0x0100, 0x953: 0x0100, 0x954: 0x0100, 0x955: 0x0100, 0x956: 0x0100, 0x957: 0x0100, 0x958: 0x0100, 0x959: 0x0100, 0x95a: 0x0100, 0x95b: 0x0100, 0x95c: 0x0100, 0x95d: 0x0100, 0x95e: 0x0100, 0x95f: 0x0100, 0x960: 0x0100, 0x961: 0x0100, 0x962: 0x0100, 0x963: 0x0100, 0x964: 0x0100, 0x965: 0x0100, 0x966: 0x0100, 0x967: 0x0100, 0x968: 0x0100, 0x969: 0x0100, 0x96a: 0x0100, 0x96b: 0x0100, 0x96c: 0x0100, 0x96d: 0x0100, 0x96e: 0x0100, 0x96f: 0x0100, 0x970: 0x0100, 0x971: 0x0100, 0x972: 0x0100, 0x973: 0x0100, 0x974: 0x0100, 0x975: 0x0100, 0x976: 0x0100, 0x977: 0x0100, 0x978: 0x0100, 0x979: 0x0100, 0x97a: 0x0008, 0x97b: 0x0008, 0x97c: 0x0008, 0x97d: 0x0100, 0x97e: 0x0008, 0x97f: 0x0008, // Block 0x26, offset 0x980 0x980: 0x0008, 0x981: 0x0008, 0x982: 0x0008, 0x983: 0x0008, 0x984: 0x0008, 0x985: 0x0008, 0x986: 0x0008, 0x987: 0x0008, 0x988: 0x0008, 0x989: 0x0008, 0x98a: 0x0008, 0x98b: 0x0008, 0x98c: 0x0008, 0x98d: 0x0008, 0x98e: 0x0008, 0x98f: 0x0008, 0x990: 0x0100, 0x991: 0x0008, 0x992: 0x0008, 0x993: 0x0008, 0x994: 0x0008, 0x995: 0x0008, 0x996: 0x0008, 0x997: 0x0008, 0x998: 0x0100, 0x999: 0x0100, 0x99a: 0x0100, 0x99b: 0x0100, 0x99c: 0x0100, 0x99d: 0x0100, 0x99e: 0x0100, 0x99f: 0x0100, 0x9a0: 0x0100, 0x9a1: 0x0100, 0x9a2: 0x0008, 0x9a3: 0x0008, 0x9a4: 0x0400, 0x9a5: 0x0400, 0x9a6: 0x0080, 0x9a7: 0x0080, 0x9a8: 0x0080, 0x9a9: 0x0080, 0x9aa: 0x0080, 0x9ab: 0x0080, 0x9ac: 0x0080, 0x9ad: 0x0080, 0x9ae: 0x0080, 0x9af: 0x0080, 0x9b1: 0x0100, 0x9b2: 0x0100, 0x9b3: 0x0100, 0x9b4: 0x0100, 0x9b5: 0x0100, 0x9b6: 0x0100, 0x9b7: 0x0100, 0x9b8: 0x0100, 0x9b9: 0x0100, 0x9ba: 0x0100, 0x9bb: 0x0100, 0x9bc: 0x0100, 0x9bd: 0x0100, 0x9be: 0x0100, 0x9bf: 0x0100, // Block 0x27, offset 0x9c0 0x9c0: 0x0100, 0x9c1: 0x0008, 0x9c2: 0x0008, 0x9c3: 0x0008, 0x9c5: 0x0100, 0x9c6: 0x0100, 0x9c7: 0x0100, 0x9c8: 0x0100, 0x9c9: 0x0100, 0x9ca: 0x0100, 0x9cb: 0x0100, 0x9cc: 0x0100, 0x9cf: 0x0100, 0x9d0: 0x0100, 0x9d3: 0x0100, 0x9d4: 0x0100, 0x9d5: 0x0100, 0x9d6: 0x0100, 0x9d7: 0x0100, 0x9d8: 0x0100, 0x9d9: 0x0100, 0x9da: 0x0100, 0x9db: 0x0100, 0x9dc: 0x0100, 0x9dd: 0x0100, 0x9de: 0x0100, 0x9df: 0x0100, 0x9e0: 0x0100, 0x9e1: 0x0100, 0x9e2: 0x0100, 0x9e3: 0x0100, 0x9e4: 0x0100, 0x9e5: 0x0100, 0x9e6: 0x0100, 0x9e7: 0x0100, 0x9e8: 0x0100, 0x9ea: 0x0100, 0x9eb: 0x0100, 0x9ec: 0x0100, 0x9ed: 0x0100, 0x9ee: 0x0100, 0x9ef: 0x0100, 0x9f0: 0x0100, 0x9f2: 0x0100, 0x9f6: 0x0100, 0x9f7: 0x0100, 0x9f8: 0x0100, 0x9f9: 0x0100, 0x9fc: 0x0008, 0x9fd: 0x0100, 0x9fe: 0x0008, 0x9ff: 0x0008, // Block 0x28, offset 0xa00 0xa00: 0x0008, 0xa01: 0x0008, 0xa02: 0x0008, 0xa03: 0x0008, 0xa04: 0x0008, 0xa07: 0x0008, 0xa08: 0x0008, 0xa0b: 0x0008, 0xa0c: 0x0008, 0xa0d: 0x0008, 0xa0e: 0x0100, 0xa17: 0x0008, 0xa1c: 0x0100, 0xa1d: 0x0100, 0xa1f: 0x0100, 0xa20: 0x0100, 0xa21: 0x0100, 0xa22: 0x0008, 0xa23: 0x0008, 0xa26: 0x0080, 0xa27: 0x0080, 0xa28: 0x0080, 0xa29: 0x0080, 0xa2a: 0x0080, 0xa2b: 0x0080, 0xa2c: 0x0080, 0xa2d: 0x0080, 0xa2e: 0x0080, 0xa2f: 0x0080, 0xa30: 0x0100, 0xa31: 0x0100, 0xa3c: 0x0100, 0xa3e: 0x0008, // Block 0x29, offset 0xa40 0xa41: 0x0008, 0xa42: 0x0008, 0xa43: 0x0008, 0xa45: 0x0100, 0xa46: 0x0100, 0xa47: 0x0100, 0xa48: 0x0100, 0xa49: 0x0100, 0xa4a: 0x0100, 0xa4f: 0x0100, 0xa50: 0x0100, 0xa53: 0x0100, 0xa54: 0x0100, 0xa55: 0x0100, 0xa56: 0x0100, 0xa57: 0x0100, 0xa58: 0x0100, 0xa59: 0x0100, 0xa5a: 0x0100, 0xa5b: 0x0100, 0xa5c: 0x0100, 0xa5d: 0x0100, 0xa5e: 0x0100, 0xa5f: 0x0100, 0xa60: 0x0100, 0xa61: 0x0100, 0xa62: 0x0100, 0xa63: 0x0100, 0xa64: 0x0100, 0xa65: 0x0100, 0xa66: 0x0100, 0xa67: 0x0100, 0xa68: 0x0100, 0xa6a: 0x0100, 0xa6b: 0x0100, 0xa6c: 0x0100, 0xa6d: 0x0100, 0xa6e: 0x0100, 0xa6f: 0x0100, 0xa70: 0x0100, 0xa72: 0x0100, 0xa73: 0x0100, 0xa75: 0x0100, 0xa76: 0x0100, 0xa78: 0x0100, 0xa79: 0x0100, 0xa7c: 0x0008, 0xa7e: 0x0008, 0xa7f: 0x0008, // Block 0x2a, offset 0xa80 0xa80: 0x0008, 0xa81: 0x0008, 0xa82: 0x0008, 0xa87: 0x0008, 0xa88: 0x0008, 0xa8b: 0x0008, 0xa8c: 0x0008, 0xa8d: 0x0008, 0xa91: 0x0008, 0xa99: 0x0100, 0xa9a: 0x0100, 0xa9b: 0x0100, 0xa9c: 0x0100, 0xa9e: 0x0100, 0xaa6: 0x0080, 0xaa7: 0x0080, 0xaa8: 0x0080, 0xaa9: 0x0080, 0xaaa: 0x0080, 0xaab: 0x0080, 0xaac: 0x0080, 0xaad: 0x0080, 0xaae: 0x0080, 0xaaf: 0x0080, 0xab0: 0x0008, 0xab1: 0x0008, 0xab2: 0x0100, 0xab3: 0x0100, 0xab4: 0x0100, 0xab5: 0x0008, // Block 0x2b, offset 0xac0 0xac1: 0x0008, 0xac2: 0x0008, 0xac3: 0x0008, 0xac5: 0x0100, 0xac6: 0x0100, 0xac7: 0x0100, 0xac8: 0x0100, 0xac9: 0x0100, 0xaca: 0x0100, 0xacb: 0x0100, 0xacc: 0x0100, 0xacd: 0x0100, 0xacf: 0x0100, 0xad0: 0x0100, 0xad1: 0x0100, 0xad3: 0x0100, 0xad4: 0x0100, 0xad5: 0x0100, 0xad6: 0x0100, 0xad7: 0x0100, 0xad8: 0x0100, 0xad9: 0x0100, 0xada: 0x0100, 0xadb: 0x0100, 0xadc: 0x0100, 0xadd: 0x0100, 0xade: 0x0100, 0xadf: 0x0100, 0xae0: 0x0100, 0xae1: 0x0100, 0xae2: 0x0100, 0xae3: 0x0100, 0xae4: 0x0100, 0xae5: 0x0100, 0xae6: 0x0100, 0xae7: 0x0100, 0xae8: 0x0100, 0xaea: 0x0100, 0xaeb: 0x0100, 0xaec: 0x0100, 0xaed: 0x0100, 0xaee: 0x0100, 0xaef: 0x0100, 0xaf0: 0x0100, 0xaf2: 0x0100, 0xaf3: 0x0100, 0xaf5: 0x0100, 0xaf6: 0x0100, 0xaf7: 0x0100, 0xaf8: 0x0100, 0xaf9: 0x0100, 0xafc: 0x0008, 0xafd: 0x0100, 0xafe: 0x0008, 0xaff: 0x0008, // Block 0x2c, offset 0xb00 0xb00: 0x0008, 0xb01: 0x0008, 0xb02: 0x0008, 0xb03: 0x0008, 0xb04: 0x0008, 0xb05: 0x0008, 0xb07: 0x0008, 0xb08: 0x0008, 0xb09: 0x0008, 0xb0b: 0x0008, 0xb0c: 0x0008, 0xb0d: 0x0008, 0xb10: 0x0100, 0xb20: 0x0100, 0xb21: 0x0100, 0xb22: 0x0008, 0xb23: 0x0008, 0xb26: 0x0080, 0xb27: 0x0080, 0xb28: 0x0080, 0xb29: 0x0080, 0xb2a: 0x0080, 0xb2b: 0x0080, 0xb2c: 0x0080, 0xb2d: 0x0080, 0xb2e: 0x0080, 0xb2f: 0x0080, 0xb39: 0x0100, 0xb3a: 0x0008, 0xb3b: 0x0008, 0xb3c: 0x0008, 0xb3d: 0x0008, 0xb3e: 0x0008, 0xb3f: 0x0008, // Block 0x2d, offset 0xb40 0xb41: 0x0008, 0xb42: 0x0008, 0xb43: 0x0008, 0xb45: 0x0100, 0xb46: 0x0100, 0xb47: 0x0100, 0xb48: 0x0100, 0xb49: 0x0100, 0xb4a: 0x0100, 0xb4b: 0x0100, 0xb4c: 0x0100, 0xb4f: 0x0100, 0xb50: 0x0100, 0xb53: 0x0100, 0xb54: 0x0100, 0xb55: 0x0100, 0xb56: 0x0100, 0xb57: 0x0100, 0xb58: 0x0100, 0xb59: 0x0100, 0xb5a: 0x0100, 0xb5b: 0x0100, 0xb5c: 0x0100, 0xb5d: 0x0100, 0xb5e: 0x0100, 0xb5f: 0x0100, 0xb60: 0x0100, 0xb61: 0x0100, 0xb62: 0x0100, 0xb63: 0x0100, 0xb64: 0x0100, 0xb65: 0x0100, 0xb66: 0x0100, 0xb67: 0x0100, 0xb68: 0x0100, 0xb6a: 0x0100, 0xb6b: 0x0100, 0xb6c: 0x0100, 0xb6d: 0x0100, 0xb6e: 0x0100, 0xb6f: 0x0100, 0xb70: 0x0100, 0xb72: 0x0100, 0xb73: 0x0100, 0xb75: 0x0100, 0xb76: 0x0100, 0xb77: 0x0100, 0xb78: 0x0100, 0xb79: 0x0100, 0xb7c: 0x0008, 0xb7d: 0x0100, 0xb7e: 0x0008, 0xb7f: 0x0008, // Block 0x2e, offset 0xb80 0xb80: 0x0008, 0xb81: 0x0008, 0xb82: 0x0008, 0xb83: 0x0008, 0xb84: 0x0008, 0xb87: 0x0008, 0xb88: 0x0008, 0xb8b: 0x0008, 0xb8c: 0x0008, 0xb8d: 0x0008, 0xb95: 0x0008, 0xb96: 0x0008, 0xb97: 0x0008, 0xb9c: 0x0100, 0xb9d: 0x0100, 0xb9f: 0x0100, 0xba0: 0x0100, 0xba1: 0x0100, 0xba2: 0x0008, 0xba3: 0x0008, 0xba6: 0x0080, 0xba7: 0x0080, 0xba8: 0x0080, 0xba9: 0x0080, 0xbaa: 0x0080, 0xbab: 0x0080, 0xbac: 0x0080, 0xbad: 0x0080, 0xbae: 0x0080, 0xbaf: 0x0080, 0xbb1: 0x0100, // Block 0x2f, offset 0xbc0 0xbc2: 0x0008, 0xbc3: 0x0100, 0xbc5: 0x0100, 0xbc6: 0x0100, 0xbc7: 0x0100, 0xbc8: 0x0100, 0xbc9: 0x0100, 0xbca: 0x0100, 0xbce: 0x0100, 0xbcf: 0x0100, 0xbd0: 0x0100, 0xbd2: 0x0100, 0xbd3: 0x0100, 0xbd4: 0x0100, 0xbd5: 0x0100, 0xbd9: 0x0100, 0xbda: 0x0100, 0xbdc: 0x0100, 0xbde: 0x0100, 0xbdf: 0x0100, 0xbe3: 0x0100, 0xbe4: 0x0100, 0xbe8: 0x0100, 0xbe9: 0x0100, 0xbea: 0x0100, 0xbee: 0x0100, 0xbef: 0x0100, 0xbf0: 0x0100, 0xbf1: 0x0100, 0xbf2: 0x0100, 0xbf3: 0x0100, 0xbf4: 0x0100, 0xbf5: 0x0100, 0xbf6: 0x0100, 0xbf7: 0x0100, 0xbf8: 0x0100, 0xbf9: 0x0100, 0xbfe: 0x0008, 0xbff: 0x0008, // Block 0x30, offset 0xc00 0xc00: 0x0008, 0xc01: 0x0008, 0xc02: 0x0008, 0xc06: 0x0008, 0xc07: 0x0008, 0xc08: 0x0008, 0xc0a: 0x0008, 0xc0b: 0x0008, 0xc0c: 0x0008, 0xc0d: 0x0008, 0xc10: 0x0100, 0xc17: 0x0008, 0xc26: 0x0080, 0xc27: 0x0080, 0xc28: 0x0080, 0xc29: 0x0080, 0xc2a: 0x0080, 0xc2b: 0x0080, 0xc2c: 0x0080, 0xc2d: 0x0080, 0xc2e: 0x0080, 0xc2f: 0x0080, // Block 0x31, offset 0xc40 0xc40: 0x0008, 0xc41: 0x0008, 0xc42: 0x0008, 0xc43: 0x0008, 0xc44: 0x0008, 0xc45: 0x0100, 0xc46: 0x0100, 0xc47: 0x0100, 0xc48: 0x0100, 0xc49: 0x0100, 0xc4a: 0x0100, 0xc4b: 0x0100, 0xc4c: 0x0100, 0xc4e: 0x0100, 0xc4f: 0x0100, 0xc50: 0x0100, 0xc52: 0x0100, 0xc53: 0x0100, 0xc54: 0x0100, 0xc55: 0x0100, 0xc56: 0x0100, 0xc57: 0x0100, 0xc58: 0x0100, 0xc59: 0x0100, 0xc5a: 0x0100, 0xc5b: 0x0100, 0xc5c: 0x0100, 0xc5d: 0x0100, 0xc5e: 0x0100, 0xc5f: 0x0100, 0xc60: 0x0100, 0xc61: 0x0100, 0xc62: 0x0100, 0xc63: 0x0100, 0xc64: 0x0100, 0xc65: 0x0100, 0xc66: 0x0100, 0xc67: 0x0100, 0xc68: 0x0100, 0xc6a: 0x0100, 0xc6b: 0x0100, 0xc6c: 0x0100, 0xc6d: 0x0100, 0xc6e: 0x0100, 0xc6f: 0x0100, 0xc70: 0x0100, 0xc71: 0x0100, 0xc72: 0x0100, 0xc73: 0x0100, 0xc74: 0x0100, 0xc75: 0x0100, 0xc76: 0x0100, 0xc77: 0x0100, 0xc78: 0x0100, 0xc79: 0x0100, 0xc7c: 0x0008, 0xc7d: 0x0100, 0xc7e: 0x0008, 0xc7f: 0x0008, // Block 0x32, offset 0xc80 0xc80: 0x0008, 0xc81: 0x0008, 0xc82: 0x0008, 0xc83: 0x0008, 0xc84: 0x0008, 0xc86: 0x0008, 0xc87: 0x0008, 0xc88: 0x0008, 0xc8a: 0x0008, 0xc8b: 0x0008, 0xc8c: 0x0008, 0xc8d: 0x0008, 0xc95: 0x0008, 0xc96: 0x0008, 0xc98: 0x0100, 0xc99: 0x0100, 0xc9a: 0x0100, 0xc9c: 0x0100, 0xc9d: 0x0100, 0xca0: 0x0100, 0xca1: 0x0100, 0xca2: 0x0008, 0xca3: 0x0008, 0xca6: 0x0080, 0xca7: 0x0080, 0xca8: 0x0080, 0xca9: 0x0080, 0xcaa: 0x0080, 0xcab: 0x0080, 0xcac: 0x0080, 0xcad: 0x0080, 0xcae: 0x0080, 0xcaf: 0x0080, // Block 0x33, offset 0xcc0 0xcc0: 0x0100, 0xcc1: 0x0008, 0xcc2: 0x0008, 0xcc3: 0x0008, 0xcc5: 0x0100, 0xcc6: 0x0100, 0xcc7: 0x0100, 0xcc8: 0x0100, 0xcc9: 0x0100, 0xcca: 0x0100, 0xccb: 0x0100, 0xccc: 0x0100, 0xcce: 0x0100, 0xccf: 0x0100, 0xcd0: 0x0100, 0xcd2: 0x0100, 0xcd3: 0x0100, 0xcd4: 0x0100, 0xcd5: 0x0100, 0xcd6: 0x0100, 0xcd7: 0x0100, 0xcd8: 0x0100, 0xcd9: 0x0100, 0xcda: 0x0100, 0xcdb: 0x0100, 0xcdc: 0x0100, 0xcdd: 0x0100, 0xcde: 0x0100, 0xcdf: 0x0100, 0xce0: 0x0100, 0xce1: 0x0100, 0xce2: 0x0100, 0xce3: 0x0100, 0xce4: 0x0100, 0xce5: 0x0100, 0xce6: 0x0100, 0xce7: 0x0100, 0xce8: 0x0100, 0xcea: 0x0100, 0xceb: 0x0100, 0xcec: 0x0100, 0xced: 0x0100, 0xcee: 0x0100, 0xcef: 0x0100, 0xcf0: 0x0100, 0xcf1: 0x0100, 0xcf2: 0x0100, 0xcf3: 0x0100, 0xcf5: 0x0100, 0xcf6: 0x0100, 0xcf7: 0x0100, 0xcf8: 0x0100, 0xcf9: 0x0100, 0xcfc: 0x0008, 0xcfd: 0x0100, 0xcfe: 0x0008, 0xcff: 0x0008, // Block 0x34, offset 0xd00 0xd00: 0x0008, 0xd01: 0x0008, 0xd02: 0x0008, 0xd03: 0x0008, 0xd04: 0x0008, 0xd06: 0x0008, 0xd07: 0x0008, 0xd08: 0x0008, 0xd0a: 0x0008, 0xd0b: 0x0008, 0xd0c: 0x0008, 0xd0d: 0x0008, 0xd15: 0x0008, 0xd16: 0x0008, 0xd1c: 0x0100, 0xd1d: 0x0100, 0xd1e: 0x0100, 0xd20: 0x0100, 0xd21: 0x0100, 0xd22: 0x0008, 0xd23: 0x0008, 0xd26: 0x0080, 0xd27: 0x0080, 0xd28: 0x0080, 0xd29: 0x0080, 0xd2a: 0x0080, 0xd2b: 0x0080, 0xd2c: 0x0080, 0xd2d: 0x0080, 0xd2e: 0x0080, 0xd2f: 0x0080, 0xd31: 0x0100, 0xd32: 0x0100, 0xd33: 0x0008, // Block 0x35, offset 0xd40 0xd40: 0x0008, 0xd41: 0x0008, 0xd42: 0x0008, 0xd43: 0x0008, 0xd44: 0x0100, 0xd45: 0x0100, 0xd46: 0x0100, 0xd47: 0x0100, 0xd48: 0x0100, 0xd49: 0x0100, 0xd4a: 0x0100, 0xd4b: 0x0100, 0xd4c: 0x0100, 0xd4e: 0x0100, 0xd4f: 0x0100, 0xd50: 0x0100, 0xd52: 0x0100, 0xd53: 0x0100, 0xd54: 0x0100, 0xd55: 0x0100, 0xd56: 0x0100, 0xd57: 0x0100, 0xd58: 0x0100, 0xd59: 0x0100, 0xd5a: 0x0100, 0xd5b: 0x0100, 0xd5c: 0x0100, 0xd5d: 0x0100, 0xd5e: 0x0100, 0xd5f: 0x0100, 0xd60: 0x0100, 0xd61: 0x0100, 0xd62: 0x0100, 0xd63: 0x0100, 0xd64: 0x0100, 0xd65: 0x0100, 0xd66: 0x0100, 0xd67: 0x0100, 0xd68: 0x0100, 0xd69: 0x0100, 0xd6a: 0x0100, 0xd6b: 0x0100, 0xd6c: 0x0100, 0xd6d: 0x0100, 0xd6e: 0x0100, 0xd6f: 0x0100, 0xd70: 0x0100, 0xd71: 0x0100, 0xd72: 0x0100, 0xd73: 0x0100, 0xd74: 0x0100, 0xd75: 0x0100, 0xd76: 0x0100, 0xd77: 0x0100, 0xd78: 0x0100, 0xd79: 0x0100, 0xd7a: 0x0100, 0xd7b: 0x0008, 0xd7c: 0x0008, 0xd7d: 0x0100, 0xd7e: 0x0008, 0xd7f: 0x0008, // Block 0x36, offset 0xd80 0xd80: 0x0008, 0xd81: 0x0008, 0xd82: 0x0008, 0xd83: 0x0008, 0xd84: 0x0008, 0xd86: 0x0008, 0xd87: 0x0008, 0xd88: 0x0008, 0xd8a: 0x0008, 0xd8b: 0x0008, 0xd8c: 0x0008, 0xd8d: 0x0008, 0xd8e: 0x0100, 0xd94: 0x0100, 0xd95: 0x0100, 0xd96: 0x0100, 0xd97: 0x0008, 0xd9f: 0x0100, 0xda0: 0x0100, 0xda1: 0x0100, 0xda2: 0x0008, 0xda3: 0x0008, 0xda6: 0x0080, 0xda7: 0x0080, 0xda8: 0x0080, 0xda9: 0x0080, 0xdaa: 0x0080, 0xdab: 0x0080, 0xdac: 0x0080, 0xdad: 0x0080, 0xdae: 0x0080, 0xdaf: 0x0080, 0xdba: 0x0100, 0xdbb: 0x0100, 0xdbc: 0x0100, 0xdbd: 0x0100, 0xdbe: 0x0100, 0xdbf: 0x0100, // Block 0x37, offset 0xdc0 0xdc1: 0x0008, 0xdc2: 0x0008, 0xdc3: 0x0008, 0xdc5: 0x0100, 0xdc6: 0x0100, 0xdc7: 0x0100, 0xdc8: 0x0100, 0xdc9: 0x0100, 0xdca: 0x0100, 0xdcb: 0x0100, 0xdcc: 0x0100, 0xdcd: 0x0100, 0xdce: 0x0100, 0xdcf: 0x0100, 0xdd0: 0x0100, 0xdd1: 0x0100, 0xdd2: 0x0100, 0xdd3: 0x0100, 0xdd4: 0x0100, 0xdd5: 0x0100, 0xdd6: 0x0100, 0xdda: 0x0100, 0xddb: 0x0100, 0xddc: 0x0100, 0xddd: 0x0100, 0xdde: 0x0100, 0xddf: 0x0100, 0xde0: 0x0100, 0xde1: 0x0100, 0xde2: 0x0100, 0xde3: 0x0100, 0xde4: 0x0100, 0xde5: 0x0100, 0xde6: 0x0100, 0xde7: 0x0100, 0xde8: 0x0100, 0xde9: 0x0100, 0xdea: 0x0100, 0xdeb: 0x0100, 0xdec: 0x0100, 0xded: 0x0100, 0xdee: 0x0100, 0xdef: 0x0100, 0xdf0: 0x0100, 0xdf1: 0x0100, 0xdf3: 0x0100, 0xdf4: 0x0100, 0xdf5: 0x0100, 0xdf6: 0x0100, 0xdf7: 0x0100, 0xdf8: 0x0100, 0xdf9: 0x0100, 0xdfa: 0x0100, 0xdfb: 0x0100, 0xdfd: 0x0100, // Block 0x38, offset 0xe00 0xe00: 0x0100, 0xe01: 0x0100, 0xe02: 0x0100, 0xe03: 0x0100, 0xe04: 0x0100, 0xe05: 0x0100, 0xe06: 0x0100, 0xe0a: 0x0008, 0xe0f: 0x0008, 0xe10: 0x0008, 0xe11: 0x0008, 0xe12: 0x0008, 0xe13: 0x0008, 0xe14: 0x0008, 0xe16: 0x0008, 0xe18: 0x0008, 0xe19: 0x0008, 0xe1a: 0x0008, 0xe1b: 0x0008, 0xe1c: 0x0008, 0xe1d: 0x0008, 0xe1e: 0x0008, 0xe1f: 0x0008, 0xe26: 0x0080, 0xe27: 0x0080, 0xe28: 0x0080, 0xe29: 0x0080, 0xe2a: 0x0080, 0xe2b: 0x0080, 0xe2c: 0x0080, 0xe2d: 0x0080, 0xe2e: 0x0080, 0xe2f: 0x0080, 0xe32: 0x0008, 0xe33: 0x0008, // Block 0x39, offset 0xe40 0xe41: 0x0100, 0xe42: 0x0100, 0xe43: 0x0100, 0xe44: 0x0100, 0xe45: 0x0100, 0xe46: 0x0100, 0xe47: 0x0100, 0xe48: 0x0100, 0xe49: 0x0100, 0xe4a: 0x0100, 0xe4b: 0x0100, 0xe4c: 0x0100, 0xe4d: 0x0100, 0xe4e: 0x0100, 0xe4f: 0x0100, 0xe50: 0x0100, 0xe51: 0x0100, 0xe52: 0x0100, 0xe53: 0x0100, 0xe54: 0x0100, 0xe55: 0x0100, 0xe56: 0x0100, 0xe57: 0x0100, 0xe58: 0x0100, 0xe59: 0x0100, 0xe5a: 0x0100, 0xe5b: 0x0100, 0xe5c: 0x0100, 0xe5d: 0x0100, 0xe5e: 0x0100, 0xe5f: 0x0100, 0xe60: 0x0100, 0xe61: 0x0100, 0xe62: 0x0100, 0xe63: 0x0100, 0xe64: 0x0100, 0xe65: 0x0100, 0xe66: 0x0100, 0xe67: 0x0100, 0xe68: 0x0100, 0xe69: 0x0100, 0xe6a: 0x0100, 0xe6b: 0x0100, 0xe6c: 0x0100, 0xe6d: 0x0100, 0xe6e: 0x0100, 0xe6f: 0x0100, 0xe70: 0x0100, 0xe71: 0x0008, 0xe72: 0x0100, 0xe73: 0x0100, 0xe74: 0x0008, 0xe75: 0x0008, 0xe76: 0x0008, 0xe77: 0x0008, 0xe78: 0x0008, 0xe79: 0x0008, 0xe7a: 0x0008, // Block 0x3a, offset 0xe80 0xe80: 0x0100, 0xe81: 0x0100, 0xe82: 0x0100, 0xe83: 0x0100, 0xe84: 0x0100, 0xe85: 0x0100, 0xe86: 0x0100, 0xe87: 0x0008, 0xe88: 0x0008, 0xe89: 0x0008, 0xe8a: 0x0008, 0xe8b: 0x0008, 0xe8c: 0x0008, 0xe8d: 0x0008, 0xe8e: 0x0008, 0xe90: 0x0080, 0xe91: 0x0080, 0xe92: 0x0080, 0xe93: 0x0080, 0xe94: 0x0080, 0xe95: 0x0080, 0xe96: 0x0080, 0xe97: 0x0080, 0xe98: 0x0080, 0xe99: 0x0080, // Block 0x3b, offset 0xec0 0xec1: 0x0100, 0xec2: 0x0100, 0xec4: 0x0100, 0xec6: 0x0100, 0xec7: 0x0100, 0xec8: 0x0100, 0xec9: 0x0100, 0xeca: 0x0100, 0xecc: 0x0100, 0xecd: 0x0100, 0xece: 0x0100, 0xecf: 0x0100, 0xed0: 0x0100, 0xed1: 0x0100, 0xed2: 0x0100, 0xed3: 0x0100, 0xed4: 0x0100, 0xed5: 0x0100, 0xed6: 0x0100, 0xed7: 0x0100, 0xed8: 0x0100, 0xed9: 0x0100, 0xeda: 0x0100, 0xedb: 0x0100, 0xedc: 0x0100, 0xedd: 0x0100, 0xede: 0x0100, 0xedf: 0x0100, 0xee0: 0x0100, 0xee1: 0x0100, 0xee2: 0x0100, 0xee3: 0x0100, 0xee5: 0x0100, 0xee7: 0x0100, 0xee8: 0x0100, 0xee9: 0x0100, 0xeea: 0x0100, 0xeeb: 0x0100, 0xeec: 0x0100, 0xeed: 0x0100, 0xeee: 0x0100, 0xeef: 0x0100, 0xef0: 0x0100, 0xef1: 0x0008, 0xef2: 0x0100, 0xef3: 0x0100, 0xef4: 0x0008, 0xef5: 0x0008, 0xef6: 0x0008, 0xef7: 0x0008, 0xef8: 0x0008, 0xef9: 0x0008, 0xefa: 0x0008, 0xefb: 0x0008, 0xefc: 0x0008, 0xefd: 0x0100, // Block 0x3c, offset 0xf00 0xf00: 0x0100, 0xf01: 0x0100, 0xf02: 0x0100, 0xf03: 0x0100, 0xf04: 0x0100, 0xf06: 0x0100, 0xf08: 0x0008, 0xf09: 0x0008, 0xf0a: 0x0008, 0xf0b: 0x0008, 0xf0c: 0x0008, 0xf0d: 0x0008, 0xf0e: 0x0008, 0xf10: 0x0080, 0xf11: 0x0080, 0xf12: 0x0080, 0xf13: 0x0080, 0xf14: 0x0080, 0xf15: 0x0080, 0xf16: 0x0080, 0xf17: 0x0080, 0xf18: 0x0080, 0xf19: 0x0080, 0xf1c: 0x0100, 0xf1d: 0x0100, 0xf1e: 0x0100, 0xf1f: 0x0100, // Block 0x3d, offset 0xf40 0xf40: 0x0100, 0xf58: 0x0008, 0xf59: 0x0008, 0xf60: 0x0080, 0xf61: 0x0080, 0xf62: 0x0080, 0xf63: 0x0080, 0xf64: 0x0080, 0xf65: 0x0080, 0xf66: 0x0080, 0xf67: 0x0080, 0xf68: 0x0080, 0xf69: 0x0080, 0xf75: 0x0008, 0xf77: 0x0008, 0xf79: 0x0008, 0xf7a: 0x0004, 0xf7b: 0x0004, 0xf7c: 0x0004, 0xf7d: 0x0004, 0xf7e: 0x0008, 0xf7f: 0x0008, // Block 0x3e, offset 0xf80 0xf80: 0x0100, 0xf81: 0x0100, 0xf82: 0x0100, 0xf83: 0x0100, 0xf84: 0x0100, 0xf85: 0x0100, 0xf86: 0x0100, 0xf87: 0x0100, 0xf89: 0x0100, 0xf8a: 0x0100, 0xf8b: 0x0100, 0xf8c: 0x0100, 0xf8d: 0x0100, 0xf8e: 0x0100, 0xf8f: 0x0100, 0xf90: 0x0100, 0xf91: 0x0100, 0xf92: 0x0100, 0xf93: 0x0100, 0xf94: 0x0100, 0xf95: 0x0100, 0xf96: 0x0100, 0xf97: 0x0100, 0xf98: 0x0100, 0xf99: 0x0100, 0xf9a: 0x0100, 0xf9b: 0x0100, 0xf9c: 0x0100, 0xf9d: 0x0100, 0xf9e: 0x0100, 0xf9f: 0x0100, 0xfa0: 0x0100, 0xfa1: 0x0100, 0xfa2: 0x0100, 0xfa3: 0x0100, 0xfa4: 0x0100, 0xfa5: 0x0100, 0xfa6: 0x0100, 0xfa7: 0x0100, 0xfa8: 0x0100, 0xfa9: 0x0100, 0xfaa: 0x0100, 0xfab: 0x0100, 0xfac: 0x0100, 0xfb1: 0x0008, 0xfb2: 0x0008, 0xfb3: 0x0008, 0xfb4: 0x0008, 0xfb5: 0x0008, 0xfb6: 0x0008, 0xfb7: 0x0008, 0xfb8: 0x0008, 0xfb9: 0x0008, 0xfba: 0x0008, 0xfbb: 0x0008, 0xfbc: 0x0008, 0xfbd: 0x0008, 0xfbe: 0x0008, 0xfbf: 0x0008, // Block 0x3f, offset 0xfc0 0xfc0: 0x0008, 0xfc1: 0x0008, 0xfc2: 0x0008, 0xfc3: 0x0008, 0xfc4: 0x0008, 0xfc6: 0x0008, 0xfc7: 0x0008, 0xfc8: 0x0100, 0xfc9: 0x0100, 0xfca: 0x0100, 0xfcb: 0x0100, 0xfcc: 0x0100, 0xfcd: 0x0008, 0xfce: 0x0008, 0xfcf: 0x0008, 0xfd0: 0x0008, 0xfd1: 0x0008, 0xfd2: 0x0008, 0xfd3: 0x0008, 0xfd4: 0x0008, 0xfd5: 0x0008, 0xfd6: 0x0008, 0xfd7: 0x0008, 0xfd9: 0x0008, 0xfda: 0x0008, 0xfdb: 0x0008, 0xfdc: 0x0008, 0xfdd: 0x0008, 0xfde: 0x0008, 0xfdf: 0x0008, 0xfe0: 0x0008, 0xfe1: 0x0008, 0xfe2: 0x0008, 0xfe3: 0x0008, 0xfe4: 0x0008, 0xfe5: 0x0008, 0xfe6: 0x0008, 0xfe7: 0x0008, 0xfe8: 0x0008, 0xfe9: 0x0008, 0xfea: 0x0008, 0xfeb: 0x0008, 0xfec: 0x0008, 0xfed: 0x0008, 0xfee: 0x0008, 0xfef: 0x0008, 0xff0: 0x0008, 0xff1: 0x0008, 0xff2: 0x0008, 0xff3: 0x0008, 0xff4: 0x0008, 0xff5: 0x0008, 0xff6: 0x0008, 0xff7: 0x0008, 0xff8: 0x0008, 0xff9: 0x0008, 0xffa: 0x0008, 0xffb: 0x0008, 0xffc: 0x0008, // Block 0x40, offset 0x1000 0x1006: 0x0008, // Block 0x41, offset 0x1040 0x1040: 0x0100, 0x1041: 0x0100, 0x1042: 0x0100, 0x1043: 0x0100, 0x1044: 0x0100, 0x1045: 0x0100, 0x1046: 0x0100, 0x1047: 0x0100, 0x1048: 0x0100, 0x1049: 0x0100, 0x104a: 0x0100, 0x104b: 0x0100, 0x104c: 0x0100, 0x104d: 0x0100, 0x104e: 0x0100, 0x104f: 0x0100, 0x1050: 0x0100, 0x1051: 0x0100, 0x1052: 0x0100, 0x1053: 0x0100, 0x1054: 0x0100, 0x1055: 0x0100, 0x1056: 0x0100, 0x1057: 0x0100, 0x1058: 0x0100, 0x1059: 0x0100, 0x105a: 0x0100, 0x105b: 0x0100, 0x105c: 0x0100, 0x105d: 0x0100, 0x105e: 0x0100, 0x105f: 0x0100, 0x1060: 0x0100, 0x1061: 0x0100, 0x1062: 0x0100, 0x1063: 0x0100, 0x1064: 0x0100, 0x1065: 0x0100, 0x1066: 0x0100, 0x1067: 0x0100, 0x1068: 0x0100, 0x1069: 0x0100, 0x106a: 0x0100, 0x106b: 0x0008, 0x106c: 0x0008, 0x106d: 0x0008, 0x106e: 0x0008, 0x106f: 0x0008, 0x1070: 0x0008, 0x1071: 0x0008, 0x1072: 0x0008, 0x1073: 0x0008, 0x1074: 0x0008, 0x1075: 0x0008, 0x1076: 0x0008, 0x1077: 0x0008, 0x1078: 0x0008, 0x1079: 0x0008, 0x107a: 0x0008, 0x107b: 0x0008, 0x107c: 0x0008, 0x107d: 0x0008, 0x107e: 0x0008, 0x107f: 0x0100, // Block 0x42, offset 0x1080 0x1080: 0x0080, 0x1081: 0x0080, 0x1082: 0x0080, 0x1083: 0x0080, 0x1084: 0x0080, 0x1085: 0x0080, 0x1086: 0x0080, 0x1087: 0x0080, 0x1088: 0x0080, 0x1089: 0x0080, 0x108a: 0x0400, 0x108b: 0x0400, 0x1090: 0x0100, 0x1091: 0x0100, 0x1092: 0x0100, 0x1093: 0x0100, 0x1094: 0x0100, 0x1095: 0x0100, 0x1096: 0x0008, 0x1097: 0x0008, 0x1098: 0x0008, 0x1099: 0x0008, 0x109a: 0x0100, 0x109b: 0x0100, 0x109c: 0x0100, 0x109d: 0x0100, 0x109e: 0x0008, 0x109f: 0x0008, 0x10a0: 0x0008, 0x10a1: 0x0100, 0x10a2: 0x0008, 0x10a3: 0x0008, 0x10a4: 0x0008, 0x10a5: 0x0100, 0x10a6: 0x0100, 0x10a7: 0x0008, 0x10a8: 0x0008, 0x10a9: 0x0008, 0x10aa: 0x0008, 0x10ab: 0x0008, 0x10ac: 0x0008, 0x10ad: 0x0008, 0x10ae: 0x0100, 0x10af: 0x0100, 0x10b0: 0x0100, 0x10b1: 0x0008, 0x10b2: 0x0008, 0x10b3: 0x0008, 0x10b4: 0x0008, 0x10b5: 0x0100, 0x10b6: 0x0100, 0x10b7: 0x0100, 0x10b8: 0x0100, 0x10b9: 0x0100, 0x10ba: 0x0100, 0x10bb: 0x0100, 0x10bc: 0x0100, 0x10bd: 0x0100, 0x10be: 0x0100, 0x10bf: 0x0100, // Block 0x43, offset 0x10c0 0x10c0: 0x0100, 0x10c1: 0x0100, 0x10c2: 0x0008, 0x10c3: 0x0008, 0x10c4: 0x0008, 0x10c5: 0x0008, 0x10c6: 0x0008, 0x10c7: 0x0008, 0x10c8: 0x0008, 0x10c9: 0x0008, 0x10ca: 0x0008, 0x10cb: 0x0008, 0x10cc: 0x0008, 0x10cd: 0x0008, 0x10ce: 0x0100, 0x10cf: 0x0008, 0x10d0: 0x0080, 0x10d1: 0x0080, 0x10d2: 0x0080, 0x10d3: 0x0080, 0x10d4: 0x0080, 0x10d5: 0x0080, 0x10d6: 0x0080, 0x10d7: 0x0080, 0x10d8: 0x0080, 0x10d9: 0x0080, 0x10da: 0x0008, 0x10db: 0x0008, 0x10dc: 0x0008, 0x10dd: 0x0008, 0x10e0: 0x2000, 0x10e1: 0x2000, 0x10e2: 0x2000, 0x10e3: 0x2000, 0x10e4: 0x2000, 0x10e5: 0x2000, 0x10e6: 0x2000, 0x10e7: 0x2000, 0x10e8: 0x2000, 0x10e9: 0x2000, 0x10ea: 0x2000, 0x10eb: 0x2000, 0x10ec: 0x2000, 0x10ed: 0x2000, 0x10ee: 0x2000, 0x10ef: 0x2000, 0x10f0: 0x2000, 0x10f1: 0x2000, 0x10f2: 0x2000, 0x10f3: 0x2000, 0x10f4: 0x2000, 0x10f5: 0x2000, 0x10f6: 0x2000, 0x10f7: 0x2000, 0x10f8: 0x2000, 0x10f9: 0x2000, 0x10fa: 0x2000, 0x10fb: 0x2000, 0x10fc: 0x2000, 0x10fd: 0x2000, 0x10fe: 0x2000, 0x10ff: 0x2000, // Block 0x44, offset 0x1100 0x1100: 0x2000, 0x1101: 0x2000, 0x1102: 0x2000, 0x1103: 0x2000, 0x1104: 0x2000, 0x1105: 0x2000, 0x1107: 0x2000, 0x110d: 0x2000, 0x1110: 0x0100, 0x1111: 0x0100, 0x1112: 0x0100, 0x1113: 0x0100, 0x1114: 0x0100, 0x1115: 0x0100, 0x1116: 0x0100, 0x1117: 0x0100, 0x1118: 0x0100, 0x1119: 0x0100, 0x111a: 0x0100, 0x111b: 0x0100, 0x111c: 0x0100, 0x111d: 0x0100, 0x111e: 0x0100, 0x111f: 0x0100, 0x1120: 0x0100, 0x1121: 0x0100, 0x1122: 0x0100, 0x1123: 0x0100, 0x1124: 0x0100, 0x1125: 0x0100, 0x1126: 0x0100, 0x1127: 0x0100, 0x1128: 0x0100, 0x1129: 0x0100, 0x112a: 0x0100, 0x112b: 0x0100, 0x112c: 0x0100, 0x112d: 0x0100, 0x112e: 0x0100, 0x112f: 0x0100, 0x1130: 0x0100, 0x1131: 0x0100, 0x1132: 0x0100, 0x1133: 0x0100, 0x1134: 0x0100, 0x1135: 0x0100, 0x1136: 0x0100, 0x1137: 0x0100, 0x1138: 0x0100, 0x1139: 0x0100, 0x113a: 0x0100, 0x113c: 0x0040, 0x113d: 0x0100, 0x113e: 0x0100, 0x113f: 0x0100, // Block 0x45, offset 0x1140 0x1140: 0x0100, 0x1141: 0x0100, 0x1142: 0x0100, 0x1143: 0x0100, 0x1144: 0x0100, 0x1145: 0x0100, 0x1146: 0x0100, 0x1147: 0x0100, 0x1148: 0x0100, 0x114a: 0x0100, 0x114b: 0x0100, 0x114c: 0x0100, 0x114d: 0x0100, 0x1150: 0x0100, 0x1151: 0x0100, 0x1152: 0x0100, 0x1153: 0x0100, 0x1154: 0x0100, 0x1155: 0x0100, 0x1156: 0x0100, 0x1158: 0x0100, 0x115a: 0x0100, 0x115b: 0x0100, 0x115c: 0x0100, 0x115d: 0x0100, 0x1160: 0x0100, 0x1161: 0x0100, 0x1162: 0x0100, 0x1163: 0x0100, 0x1164: 0x0100, 0x1165: 0x0100, 0x1166: 0x0100, 0x1167: 0x0100, 0x1168: 0x0100, 0x1169: 0x0100, 0x116a: 0x0100, 0x116b: 0x0100, 0x116c: 0x0100, 0x116d: 0x0100, 0x116e: 0x0100, 0x116f: 0x0100, 0x1170: 0x0100, 0x1171: 0x0100, 0x1172: 0x0100, 0x1173: 0x0100, 0x1174: 0x0100, 0x1175: 0x0100, 0x1176: 0x0100, 0x1177: 0x0100, 0x1178: 0x0100, 0x1179: 0x0100, 0x117a: 0x0100, 0x117b: 0x0100, 0x117c: 0x0100, 0x117d: 0x0100, 0x117e: 0x0100, 0x117f: 0x0100, // Block 0x46, offset 0x1180 0x1180: 0x0100, 0x1181: 0x0100, 0x1182: 0x0100, 0x1183: 0x0100, 0x1184: 0x0100, 0x1185: 0x0100, 0x1186: 0x0100, 0x1187: 0x0100, 0x1188: 0x0100, 0x118a: 0x0100, 0x118b: 0x0100, 0x118c: 0x0100, 0x118d: 0x0100, 0x1190: 0x0100, 0x1191: 0x0100, 0x1192: 0x0100, 0x1193: 0x0100, 0x1194: 0x0100, 0x1195: 0x0100, 0x1196: 0x0100, 0x1197: 0x0100, 0x1198: 0x0100, 0x1199: 0x0100, 0x119a: 0x0100, 0x119b: 0x0100, 0x119c: 0x0100, 0x119d: 0x0100, 0x119e: 0x0100, 0x119f: 0x0100, 0x11a0: 0x0100, 0x11a1: 0x0100, 0x11a2: 0x0100, 0x11a3: 0x0100, 0x11a4: 0x0100, 0x11a5: 0x0100, 0x11a6: 0x0100, 0x11a7: 0x0100, 0x11a8: 0x0100, 0x11a9: 0x0100, 0x11aa: 0x0100, 0x11ab: 0x0100, 0x11ac: 0x0100, 0x11ad: 0x0100, 0x11ae: 0x0100, 0x11af: 0x0100, 0x11b0: 0x0100, 0x11b2: 0x0100, 0x11b3: 0x0100, 0x11b4: 0x0100, 0x11b5: 0x0100, 0x11b8: 0x0100, 0x11b9: 0x0100, 0x11ba: 0x0100, 0x11bb: 0x0100, 0x11bc: 0x0100, 0x11bd: 0x0100, 0x11be: 0x0100, // Block 0x47, offset 0x11c0 0x11c0: 0x0100, 0x11c2: 0x0100, 0x11c3: 0x0100, 0x11c4: 0x0100, 0x11c5: 0x0100, 0x11c8: 0x0100, 0x11c9: 0x0100, 0x11ca: 0x0100, 0x11cb: 0x0100, 0x11cc: 0x0100, 0x11cd: 0x0100, 0x11ce: 0x0100, 0x11cf: 0x0100, 0x11d0: 0x0100, 0x11d1: 0x0100, 0x11d2: 0x0100, 0x11d3: 0x0100, 0x11d4: 0x0100, 0x11d5: 0x0100, 0x11d6: 0x0100, 0x11d8: 0x0100, 0x11d9: 0x0100, 0x11da: 0x0100, 0x11db: 0x0100, 0x11dc: 0x0100, 0x11dd: 0x0100, 0x11de: 0x0100, 0x11df: 0x0100, 0x11e0: 0x0100, 0x11e1: 0x0100, 0x11e2: 0x0100, 0x11e3: 0x0100, 0x11e4: 0x0100, 0x11e5: 0x0100, 0x11e6: 0x0100, 0x11e7: 0x0100, 0x11e8: 0x0100, 0x11e9: 0x0100, 0x11ea: 0x0100, 0x11eb: 0x0100, 0x11ec: 0x0100, 0x11ed: 0x0100, 0x11ee: 0x0100, 0x11ef: 0x0100, 0x11f0: 0x0100, 0x11f1: 0x0100, 0x11f2: 0x0100, 0x11f3: 0x0100, 0x11f4: 0x0100, 0x11f5: 0x0100, 0x11f6: 0x0100, 0x11f7: 0x0100, 0x11f8: 0x0100, 0x11f9: 0x0100, 0x11fa: 0x0100, 0x11fb: 0x0100, 0x11fc: 0x0100, 0x11fd: 0x0100, 0x11fe: 0x0100, 0x11ff: 0x0100, // Block 0x48, offset 0x1200 0x1200: 0x0100, 0x1201: 0x0100, 0x1202: 0x0100, 0x1203: 0x0100, 0x1204: 0x0100, 0x1205: 0x0100, 0x1206: 0x0100, 0x1207: 0x0100, 0x1208: 0x0100, 0x1209: 0x0100, 0x120a: 0x0100, 0x120b: 0x0100, 0x120c: 0x0100, 0x120d: 0x0100, 0x120e: 0x0100, 0x120f: 0x0100, 0x1210: 0x0100, 0x1212: 0x0100, 0x1213: 0x0100, 0x1214: 0x0100, 0x1215: 0x0100, 0x1218: 0x0100, 0x1219: 0x0100, 0x121a: 0x0100, 0x121b: 0x0100, 0x121c: 0x0100, 0x121d: 0x0100, 0x121e: 0x0100, 0x121f: 0x0100, 0x1220: 0x0100, 0x1221: 0x0100, 0x1222: 0x0100, 0x1223: 0x0100, 0x1224: 0x0100, 0x1225: 0x0100, 0x1226: 0x0100, 0x1227: 0x0100, 0x1228: 0x0100, 0x1229: 0x0100, 0x122a: 0x0100, 0x122b: 0x0100, 0x122c: 0x0100, 0x122d: 0x0100, 0x122e: 0x0100, 0x122f: 0x0100, 0x1230: 0x0100, 0x1231: 0x0100, 0x1232: 0x0100, 0x1233: 0x0100, 0x1234: 0x0100, 0x1235: 0x0100, 0x1236: 0x0100, 0x1237: 0x0100, 0x1238: 0x0100, 0x1239: 0x0100, 0x123a: 0x0100, 0x123b: 0x0100, 0x123c: 0x0100, 0x123d: 0x0100, 0x123e: 0x0100, 0x123f: 0x0100, // Block 0x49, offset 0x1240 0x1240: 0x0100, 0x1241: 0x0100, 0x1242: 0x0100, 0x1243: 0x0100, 0x1244: 0x0100, 0x1245: 0x0100, 0x1246: 0x0100, 0x1247: 0x0100, 0x1248: 0x0100, 0x1249: 0x0100, 0x124a: 0x0100, 0x124b: 0x0100, 0x124c: 0x0100, 0x124d: 0x0100, 0x124e: 0x0100, 0x124f: 0x0100, 0x1250: 0x0100, 0x1251: 0x0100, 0x1252: 0x0100, 0x1253: 0x0100, 0x1254: 0x0100, 0x1255: 0x0100, 0x1256: 0x0100, 0x1257: 0x0100, 0x1258: 0x0100, 0x1259: 0x0100, 0x125a: 0x0100, 0x125d: 0x0008, 0x125e: 0x0008, 0x125f: 0x0008, 0x1262: 0x0400, 0x1267: 0x0400, 0x1268: 0x0400, // Block 0x4a, offset 0x1280 0x1280: 0x0100, 0x1281: 0x0100, 0x1282: 0x0100, 0x1283: 0x0100, 0x1284: 0x0100, 0x1285: 0x0100, 0x1286: 0x0100, 0x1287: 0x0100, 0x1288: 0x0100, 0x1289: 0x0100, 0x128a: 0x0100, 0x128b: 0x0100, 0x128c: 0x0100, 0x128d: 0x0100, 0x128e: 0x0100, 0x128f: 0x0100, 0x12a0: 0x2000, 0x12a1: 0x2000, 0x12a2: 0x2000, 0x12a3: 0x2000, 0x12a4: 0x2000, 0x12a5: 0x2000, 0x12a6: 0x2000, 0x12a7: 0x2000, 0x12a8: 0x2000, 0x12a9: 0x2000, 0x12aa: 0x2000, 0x12ab: 0x2000, 0x12ac: 0x2000, 0x12ad: 0x2000, 0x12ae: 0x2000, 0x12af: 0x2000, 0x12b0: 0x2000, 0x12b1: 0x2000, 0x12b2: 0x2000, 0x12b3: 0x2000, 0x12b4: 0x2000, 0x12b5: 0x2000, 0x12b6: 0x2000, 0x12b7: 0x2000, 0x12b8: 0x2000, 0x12b9: 0x2000, 0x12ba: 0x2000, 0x12bb: 0x2000, 0x12bc: 0x2000, 0x12bd: 0x2000, 0x12be: 0x2000, 0x12bf: 0x2000, // Block 0x4b, offset 0x12c0 0x12c0: 0x2000, 0x12c1: 0x2000, 0x12c2: 0x2000, 0x12c3: 0x2000, 0x12c4: 0x2000, 0x12c5: 0x2000, 0x12c6: 0x2000, 0x12c7: 0x2000, 0x12c8: 0x2000, 0x12c9: 0x2000, 0x12ca: 0x2000, 0x12cb: 0x2000, 0x12cc: 0x2000, 0x12cd: 0x2000, 0x12ce: 0x2000, 0x12cf: 0x2000, 0x12d0: 0x2000, 0x12d1: 0x2000, 0x12d2: 0x2000, 0x12d3: 0x2000, 0x12d4: 0x2000, 0x12d5: 0x2000, 0x12d6: 0x2000, 0x12d7: 0x2000, 0x12d8: 0x2000, 0x12d9: 0x2000, 0x12da: 0x2000, 0x12db: 0x2000, 0x12dc: 0x2000, 0x12dd: 0x2000, 0x12de: 0x2000, 0x12df: 0x2000, 0x12e0: 0x2000, 0x12e1: 0x2000, 0x12e2: 0x2000, 0x12e3: 0x2000, 0x12e4: 0x2000, 0x12e5: 0x2000, 0x12e6: 0x2000, 0x12e7: 0x2000, 0x12e8: 0x2000, 0x12e9: 0x2000, 0x12ea: 0x2000, 0x12eb: 0x2000, 0x12ec: 0x2000, 0x12ed: 0x2000, 0x12ee: 0x2000, 0x12ef: 0x2000, 0x12f0: 0x2000, 0x12f1: 0x2000, 0x12f2: 0x2000, 0x12f3: 0x2000, 0x12f4: 0x2000, 0x12f5: 0x2000, 0x12f8: 0x0040, 0x12f9: 0x0040, 0x12fa: 0x0040, 0x12fb: 0x0040, 0x12fc: 0x0040, 0x12fd: 0x0040, // Block 0x4c, offset 0x1300 0x1301: 0x0100, 0x1302: 0x0100, 0x1303: 0x0100, 0x1304: 0x0100, 0x1305: 0x0100, 0x1306: 0x0100, 0x1307: 0x0100, 0x1308: 0x0100, 0x1309: 0x0100, 0x130a: 0x0100, 0x130b: 0x0100, 0x130c: 0x0100, 0x130d: 0x0100, 0x130e: 0x0100, 0x130f: 0x0100, 0x1310: 0x0100, 0x1311: 0x0100, 0x1312: 0x0100, 0x1313: 0x0100, 0x1314: 0x0100, 0x1315: 0x0100, 0x1316: 0x0100, 0x1317: 0x0100, 0x1318: 0x0100, 0x1319: 0x0100, 0x131a: 0x0100, 0x131b: 0x0100, 0x131c: 0x0100, 0x131d: 0x0100, 0x131e: 0x0100, 0x131f: 0x0100, 0x1320: 0x0100, 0x1321: 0x0100, 0x1322: 0x0100, 0x1323: 0x0100, 0x1324: 0x0100, 0x1325: 0x0100, 0x1326: 0x0100, 0x1327: 0x0100, 0x1328: 0x0100, 0x1329: 0x0100, 0x132a: 0x0100, 0x132b: 0x0100, 0x132c: 0x0100, 0x132d: 0x0100, 0x132e: 0x0100, 0x132f: 0x0100, 0x1330: 0x0100, 0x1331: 0x0100, 0x1332: 0x0100, 0x1333: 0x0100, 0x1334: 0x0100, 0x1335: 0x0100, 0x1336: 0x0100, 0x1337: 0x0100, 0x1338: 0x0100, 0x1339: 0x0100, 0x133a: 0x0100, 0x133b: 0x0100, 0x133c: 0x0100, 0x133d: 0x0100, 0x133e: 0x0100, 0x133f: 0x0100, // Block 0x4d, offset 0x1340 0x1340: 0x0100, 0x1341: 0x0100, 0x1342: 0x0100, 0x1343: 0x0100, 0x1344: 0x0100, 0x1345: 0x0100, 0x1346: 0x0100, 0x1347: 0x0100, 0x1348: 0x0100, 0x1349: 0x0100, 0x134a: 0x0100, 0x134b: 0x0100, 0x134c: 0x0100, 0x134d: 0x0100, 0x134e: 0x0100, 0x134f: 0x0100, 0x1350: 0x0100, 0x1351: 0x0100, 0x1352: 0x0100, 0x1353: 0x0100, 0x1354: 0x0100, 0x1355: 0x0100, 0x1356: 0x0100, 0x1357: 0x0100, 0x1358: 0x0100, 0x1359: 0x0100, 0x135a: 0x0100, 0x135b: 0x0100, 0x135c: 0x0100, 0x135d: 0x0100, 0x135e: 0x0100, 0x135f: 0x0100, 0x1360: 0x0100, 0x1361: 0x0100, 0x1362: 0x0100, 0x1363: 0x0100, 0x1364: 0x0100, 0x1365: 0x0100, 0x1366: 0x0100, 0x1367: 0x0100, 0x1368: 0x0100, 0x1369: 0x0100, 0x136a: 0x0100, 0x136b: 0x0100, 0x136c: 0x0100, 0x136e: 0x0400, 0x136f: 0x0100, 0x1370: 0x0100, 0x1371: 0x0100, 0x1372: 0x0100, 0x1373: 0x0100, 0x1374: 0x0100, 0x1375: 0x0100, 0x1376: 0x0100, 0x1377: 0x0100, 0x1378: 0x0100, 0x1379: 0x0100, 0x137a: 0x0100, 0x137b: 0x0100, 0x137c: 0x0100, 0x137d: 0x0100, 0x137e: 0x0100, 0x137f: 0x0100, // Block 0x4e, offset 0x1380 0x1380: 0x1000, 0x1381: 0x0100, 0x1382: 0x0100, 0x1383: 0x0100, 0x1384: 0x0100, 0x1385: 0x0100, 0x1386: 0x0100, 0x1387: 0x0100, 0x1388: 0x0100, 0x1389: 0x0100, 0x138a: 0x0100, 0x138b: 0x0100, 0x138c: 0x0100, 0x138d: 0x0100, 0x138e: 0x0100, 0x138f: 0x0100, 0x1390: 0x0100, 0x1391: 0x0100, 0x1392: 0x0100, 0x1393: 0x0100, 0x1394: 0x0100, 0x1395: 0x0100, 0x1396: 0x0100, 0x1397: 0x0100, 0x1398: 0x0100, 0x1399: 0x0100, 0x139a: 0x0100, 0x139b: 0x0004, 0x139c: 0x0004, 0x13a0: 0x0100, 0x13a1: 0x0100, 0x13a2: 0x0100, 0x13a3: 0x0100, 0x13a4: 0x0100, 0x13a5: 0x0100, 0x13a6: 0x0100, 0x13a7: 0x0100, 0x13a8: 0x0100, 0x13a9: 0x0100, 0x13aa: 0x0100, 0x13ab: 0x0100, 0x13ac: 0x0100, 0x13ad: 0x0100, 0x13ae: 0x0100, 0x13af: 0x0100, 0x13b0: 0x0100, 0x13b1: 0x0100, 0x13b2: 0x0100, 0x13b3: 0x0100, 0x13b4: 0x0100, 0x13b5: 0x0100, 0x13b6: 0x0100, 0x13b7: 0x0100, 0x13b8: 0x0100, 0x13b9: 0x0100, 0x13ba: 0x0100, 0x13bb: 0x0100, 0x13bc: 0x0100, 0x13bd: 0x0100, 0x13be: 0x0100, 0x13bf: 0x0100, // Block 0x4f, offset 0x13c0 0x13c0: 0x0100, 0x13c1: 0x0100, 0x13c2: 0x0100, 0x13c3: 0x0100, 0x13c4: 0x0100, 0x13c5: 0x0100, 0x13c6: 0x0100, 0x13c7: 0x0100, 0x13c8: 0x0100, 0x13c9: 0x0100, 0x13ca: 0x0100, 0x13cb: 0x0100, 0x13cc: 0x0100, 0x13cd: 0x0100, 0x13ce: 0x0100, 0x13cf: 0x0100, 0x13d0: 0x0100, 0x13d1: 0x0100, 0x13d2: 0x0100, 0x13d3: 0x0100, 0x13d4: 0x0100, 0x13d5: 0x0100, 0x13d6: 0x0100, 0x13d7: 0x0100, 0x13d8: 0x0100, 0x13d9: 0x0100, 0x13da: 0x0100, 0x13db: 0x0100, 0x13dc: 0x0100, 0x13dd: 0x0100, 0x13de: 0x0100, 0x13df: 0x0100, 0x13e0: 0x0100, 0x13e1: 0x0100, 0x13e2: 0x0100, 0x13e3: 0x0100, 0x13e4: 0x0100, 0x13e5: 0x0100, 0x13e6: 0x0100, 0x13e7: 0x0100, 0x13e8: 0x0100, 0x13e9: 0x0100, 0x13ea: 0x0100, 0x13ee: 0x0100, 0x13ef: 0x0100, 0x13f0: 0x0100, 0x13f1: 0x0100, 0x13f2: 0x0100, 0x13f3: 0x0100, 0x13f4: 0x0100, 0x13f5: 0x0100, 0x13f6: 0x0100, 0x13f7: 0x0100, 0x13f8: 0x0100, // Block 0x50, offset 0x1400 0x1400: 0x0100, 0x1401: 0x0100, 0x1402: 0x0100, 0x1403: 0x0100, 0x1404: 0x0100, 0x1405: 0x0100, 0x1406: 0x0100, 0x1407: 0x0100, 0x1408: 0x0100, 0x1409: 0x0100, 0x140a: 0x0100, 0x140b: 0x0100, 0x140c: 0x0100, 0x140d: 0x0100, 0x140e: 0x0100, 0x140f: 0x0100, 0x1410: 0x0100, 0x1411: 0x0100, 0x1412: 0x0008, 0x1413: 0x0008, 0x1414: 0x0008, 0x1415: 0x0008, 0x141f: 0x0100, 0x1420: 0x0100, 0x1421: 0x0100, 0x1422: 0x0100, 0x1423: 0x0100, 0x1424: 0x0100, 0x1425: 0x0100, 0x1426: 0x0100, 0x1427: 0x0100, 0x1428: 0x0100, 0x1429: 0x0100, 0x142a: 0x0100, 0x142b: 0x0100, 0x142c: 0x0100, 0x142d: 0x0100, 0x142e: 0x0100, 0x142f: 0x0100, 0x1430: 0x0100, 0x1431: 0x0100, 0x1432: 0x0008, 0x1433: 0x0008, 0x1434: 0x0008, 0x1435: 0x0400, 0x1436: 0x0400, // Block 0x51, offset 0x1440 0x1440: 0x0100, 0x1441: 0x0100, 0x1442: 0x0100, 0x1443: 0x0100, 0x1444: 0x0100, 0x1445: 0x0100, 0x1446: 0x0100, 0x1447: 0x0100, 0x1448: 0x0100, 0x1449: 0x0100, 0x144a: 0x0100, 0x144b: 0x0100, 0x144c: 0x0100, 0x144d: 0x0100, 0x144e: 0x0100, 0x144f: 0x0100, 0x1450: 0x0100, 0x1451: 0x0100, 0x1452: 0x0008, 0x1453: 0x0008, 0x1460: 0x0100, 0x1461: 0x0100, 0x1462: 0x0100, 0x1463: 0x0100, 0x1464: 0x0100, 0x1465: 0x0100, 0x1466: 0x0100, 0x1467: 0x0100, 0x1468: 0x0100, 0x1469: 0x0100, 0x146a: 0x0100, 0x146b: 0x0100, 0x146c: 0x0100, 0x146e: 0x0100, 0x146f: 0x0100, 0x1470: 0x0100, 0x1472: 0x0008, 0x1473: 0x0008, // Block 0x52, offset 0x1480 0x1480: 0x0100, 0x1481: 0x0100, 0x1482: 0x0100, 0x1483: 0x0100, 0x1484: 0x0100, 0x1485: 0x0100, 0x1486: 0x0100, 0x1487: 0x0100, 0x1488: 0x0100, 0x1489: 0x0100, 0x148a: 0x0100, 0x148b: 0x0100, 0x148c: 0x0100, 0x148d: 0x0100, 0x148e: 0x0100, 0x148f: 0x0100, 0x1490: 0x0100, 0x1491: 0x0100, 0x1492: 0x0100, 0x1493: 0x0100, 0x1494: 0x0100, 0x1495: 0x0100, 0x1496: 0x0100, 0x1497: 0x0100, 0x1498: 0x0100, 0x1499: 0x0100, 0x149a: 0x0100, 0x149b: 0x0100, 0x149c: 0x0100, 0x149d: 0x0100, 0x149e: 0x0100, 0x149f: 0x0100, 0x14a0: 0x0100, 0x14a1: 0x0100, 0x14a2: 0x0100, 0x14a3: 0x0100, 0x14a4: 0x0100, 0x14a5: 0x0100, 0x14a6: 0x0100, 0x14a7: 0x0100, 0x14a8: 0x0100, 0x14a9: 0x0100, 0x14aa: 0x0100, 0x14ab: 0x0100, 0x14ac: 0x0100, 0x14ad: 0x0100, 0x14ae: 0x0100, 0x14af: 0x0100, 0x14b0: 0x0100, 0x14b1: 0x0100, 0x14b2: 0x0100, 0x14b3: 0x0100, 0x14b4: 0x0008, 0x14b5: 0x0008, 0x14b6: 0x0008, 0x14b7: 0x0008, 0x14b8: 0x0008, 0x14b9: 0x0008, 0x14ba: 0x0008, 0x14bb: 0x0008, 0x14bc: 0x0008, 0x14bd: 0x0008, 0x14be: 0x0008, 0x14bf: 0x0008, // Block 0x53, offset 0x14c0 0x14c0: 0x0008, 0x14c1: 0x0008, 0x14c2: 0x0008, 0x14c3: 0x0008, 0x14c4: 0x0008, 0x14c5: 0x0008, 0x14c6: 0x0008, 0x14c7: 0x0008, 0x14c8: 0x0008, 0x14c9: 0x0008, 0x14ca: 0x0008, 0x14cb: 0x0008, 0x14cc: 0x0008, 0x14cd: 0x0008, 0x14ce: 0x0008, 0x14cf: 0x0008, 0x14d0: 0x0008, 0x14d1: 0x0008, 0x14d2: 0x0008, 0x14d3: 0x0008, 0x14d4: 0x0400, 0x14d5: 0x0400, 0x14d7: 0x0100, 0x14dc: 0x0100, 0x14dd: 0x0008, 0x14e0: 0x0080, 0x14e1: 0x0080, 0x14e2: 0x0080, 0x14e3: 0x0080, 0x14e4: 0x0080, 0x14e5: 0x0080, 0x14e6: 0x0080, 0x14e7: 0x0080, 0x14e8: 0x0080, 0x14e9: 0x0080, // Block 0x54, offset 0x1500 0x1502: 0x0200, 0x1503: 0x0400, 0x1508: 0x0200, 0x1509: 0x0400, 0x150b: 0x0008, 0x150c: 0x0008, 0x150d: 0x0008, 0x150e: 0x0010, 0x150f: 0x0008, 0x1510: 0x0080, 0x1511: 0x0080, 0x1512: 0x0080, 0x1513: 0x0080, 0x1514: 0x0080, 0x1515: 0x0080, 0x1516: 0x0080, 0x1517: 0x0080, 0x1518: 0x0080, 0x1519: 0x0080, 0x1520: 0x0100, 0x1521: 0x0100, 0x1522: 0x0100, 0x1523: 0x0100, 0x1524: 0x0100, 0x1525: 0x0100, 0x1526: 0x0100, 0x1527: 0x0100, 0x1528: 0x0100, 0x1529: 0x0100, 0x152a: 0x0100, 0x152b: 0x0100, 0x152c: 0x0100, 0x152d: 0x0100, 0x152e: 0x0100, 0x152f: 0x0100, 0x1530: 0x0100, 0x1531: 0x0100, 0x1532: 0x0100, 0x1533: 0x0100, 0x1534: 0x0100, 0x1535: 0x0100, 0x1536: 0x0100, 0x1537: 0x0100, 0x1538: 0x0100, 0x1539: 0x0100, 0x153a: 0x0100, 0x153b: 0x0100, 0x153c: 0x0100, 0x153d: 0x0100, 0x153e: 0x0100, 0x153f: 0x0100, // Block 0x55, offset 0x1540 0x1540: 0x0100, 0x1541: 0x0100, 0x1542: 0x0100, 0x1543: 0x0100, 0x1544: 0x0100, 0x1545: 0x0100, 0x1546: 0x0100, 0x1547: 0x0100, 0x1548: 0x0100, 0x1549: 0x0100, 0x154a: 0x0100, 0x154b: 0x0100, 0x154c: 0x0100, 0x154d: 0x0100, 0x154e: 0x0100, 0x154f: 0x0100, 0x1550: 0x0100, 0x1551: 0x0100, 0x1552: 0x0100, 0x1553: 0x0100, 0x1554: 0x0100, 0x1555: 0x0100, 0x1556: 0x0100, 0x1557: 0x0100, 0x1558: 0x0100, 0x1559: 0x0100, 0x155a: 0x0100, 0x155b: 0x0100, 0x155c: 0x0100, 0x155d: 0x0100, 0x155e: 0x0100, 0x155f: 0x0100, 0x1560: 0x0100, 0x1561: 0x0100, 0x1562: 0x0100, 0x1563: 0x0100, 0x1564: 0x0100, 0x1565: 0x0100, 0x1566: 0x0100, 0x1567: 0x0100, 0x1568: 0x0100, 0x1569: 0x0100, 0x156a: 0x0100, 0x156b: 0x0100, 0x156c: 0x0100, 0x156d: 0x0100, 0x156e: 0x0100, 0x156f: 0x0100, 0x1570: 0x0100, 0x1571: 0x0100, 0x1572: 0x0100, 0x1573: 0x0100, 0x1574: 0x0100, 0x1575: 0x0100, 0x1576: 0x0100, 0x1577: 0x0100, 0x1578: 0x0100, // Block 0x56, offset 0x1580 0x1580: 0x0100, 0x1581: 0x0100, 0x1582: 0x0100, 0x1583: 0x0100, 0x1584: 0x0100, 0x1585: 0x0008, 0x1586: 0x0008, 0x1587: 0x0100, 0x1588: 0x0100, 0x1589: 0x0100, 0x158a: 0x0100, 0x158b: 0x0100, 0x158c: 0x0100, 0x158d: 0x0100, 0x158e: 0x0100, 0x158f: 0x0100, 0x1590: 0x0100, 0x1591: 0x0100, 0x1592: 0x0100, 0x1593: 0x0100, 0x1594: 0x0100, 0x1595: 0x0100, 0x1596: 0x0100, 0x1597: 0x0100, 0x1598: 0x0100, 0x1599: 0x0100, 0x159a: 0x0100, 0x159b: 0x0100, 0x159c: 0x0100, 0x159d: 0x0100, 0x159e: 0x0100, 0x159f: 0x0100, 0x15a0: 0x0100, 0x15a1: 0x0100, 0x15a2: 0x0100, 0x15a3: 0x0100, 0x15a4: 0x0100, 0x15a5: 0x0100, 0x15a6: 0x0100, 0x15a7: 0x0100, 0x15a8: 0x0100, 0x15a9: 0x0008, 0x15aa: 0x0100, 0x15b0: 0x0100, 0x15b1: 0x0100, 0x15b2: 0x0100, 0x15b3: 0x0100, 0x15b4: 0x0100, 0x15b5: 0x0100, 0x15b6: 0x0100, 0x15b7: 0x0100, 0x15b8: 0x0100, 0x15b9: 0x0100, 0x15ba: 0x0100, 0x15bb: 0x0100, 0x15bc: 0x0100, 0x15bd: 0x0100, 0x15be: 0x0100, 0x15bf: 0x0100, // Block 0x57, offset 0x15c0 0x15c0: 0x0100, 0x15c1: 0x0100, 0x15c2: 0x0100, 0x15c3: 0x0100, 0x15c4: 0x0100, 0x15c5: 0x0100, 0x15c6: 0x0100, 0x15c7: 0x0100, 0x15c8: 0x0100, 0x15c9: 0x0100, 0x15ca: 0x0100, 0x15cb: 0x0100, 0x15cc: 0x0100, 0x15cd: 0x0100, 0x15ce: 0x0100, 0x15cf: 0x0100, 0x15d0: 0x0100, 0x15d1: 0x0100, 0x15d2: 0x0100, 0x15d3: 0x0100, 0x15d4: 0x0100, 0x15d5: 0x0100, 0x15d6: 0x0100, 0x15d7: 0x0100, 0x15d8: 0x0100, 0x15d9: 0x0100, 0x15da: 0x0100, 0x15db: 0x0100, 0x15dc: 0x0100, 0x15dd: 0x0100, 0x15de: 0x0100, 0x15df: 0x0100, 0x15e0: 0x0100, 0x15e1: 0x0100, 0x15e2: 0x0100, 0x15e3: 0x0100, 0x15e4: 0x0100, 0x15e5: 0x0100, 0x15e6: 0x0100, 0x15e7: 0x0100, 0x15e8: 0x0100, 0x15e9: 0x0100, 0x15ea: 0x0100, 0x15eb: 0x0100, 0x15ec: 0x0100, 0x15ed: 0x0100, 0x15ee: 0x0100, 0x15ef: 0x0100, 0x15f0: 0x0100, 0x15f1: 0x0100, 0x15f2: 0x0100, 0x15f3: 0x0100, 0x15f4: 0x0100, 0x15f5: 0x0100, // Block 0x58, offset 0x1600 0x1600: 0x0100, 0x1601: 0x0100, 0x1602: 0x0100, 0x1603: 0x0100, 0x1604: 0x0100, 0x1605: 0x0100, 0x1606: 0x0100, 0x1607: 0x0100, 0x1608: 0x0100, 0x1609: 0x0100, 0x160a: 0x0100, 0x160b: 0x0100, 0x160c: 0x0100, 0x160d: 0x0100, 0x160e: 0x0100, 0x160f: 0x0100, 0x1610: 0x0100, 0x1611: 0x0100, 0x1612: 0x0100, 0x1613: 0x0100, 0x1614: 0x0100, 0x1615: 0x0100, 0x1616: 0x0100, 0x1617: 0x0100, 0x1618: 0x0100, 0x1619: 0x0100, 0x161a: 0x0100, 0x161b: 0x0100, 0x161c: 0x0100, 0x161d: 0x0100, 0x161e: 0x0100, 0x1620: 0x0008, 0x1621: 0x0008, 0x1622: 0x0008, 0x1623: 0x0008, 0x1624: 0x0008, 0x1625: 0x0008, 0x1626: 0x0008, 0x1627: 0x0008, 0x1628: 0x0008, 0x1629: 0x0008, 0x162a: 0x0008, 0x162b: 0x0008, 0x1630: 0x0008, 0x1631: 0x0008, 0x1632: 0x0008, 0x1633: 0x0008, 0x1634: 0x0008, 0x1635: 0x0008, 0x1636: 0x0008, 0x1637: 0x0008, 0x1638: 0x0008, 0x1639: 0x0008, 0x163a: 0x0008, 0x163b: 0x0008, // Block 0x59, offset 0x1640 0x1644: 0x0400, 0x1645: 0x0400, 0x1646: 0x0080, 0x1647: 0x0080, 0x1648: 0x0080, 0x1649: 0x0080, 0x164a: 0x0080, 0x164b: 0x0080, 0x164c: 0x0080, 0x164d: 0x0080, 0x164e: 0x0080, 0x164f: 0x0080, 0x1650: 0x0100, 0x1651: 0x0100, 0x1652: 0x0100, 0x1653: 0x0100, 0x1654: 0x0100, 0x1655: 0x0100, 0x1656: 0x0100, 0x1657: 0x0100, 0x1658: 0x0100, 0x1659: 0x0100, 0x165a: 0x0100, 0x165b: 0x0100, 0x165c: 0x0100, 0x165d: 0x0100, 0x165e: 0x0100, 0x165f: 0x0100, 0x1660: 0x0100, 0x1661: 0x0100, 0x1662: 0x0100, 0x1663: 0x0100, 0x1664: 0x0100, 0x1665: 0x0100, 0x1666: 0x0100, 0x1667: 0x0100, 0x1668: 0x0100, 0x1669: 0x0100, 0x166a: 0x0100, 0x166b: 0x0100, 0x166c: 0x0100, 0x166d: 0x0100, 0x1670: 0x0100, 0x1671: 0x0100, 0x1672: 0x0100, 0x1673: 0x0100, 0x1674: 0x0100, // Block 0x5a, offset 0x1680 0x1680: 0x0100, 0x1681: 0x0100, 0x1682: 0x0100, 0x1683: 0x0100, 0x1684: 0x0100, 0x1685: 0x0100, 0x1686: 0x0100, 0x1687: 0x0100, 0x1688: 0x0100, 0x1689: 0x0100, 0x168a: 0x0100, 0x168b: 0x0100, 0x168c: 0x0100, 0x168d: 0x0100, 0x168e: 0x0100, 0x168f: 0x0100, 0x1690: 0x0100, 0x1691: 0x0100, 0x1692: 0x0100, 0x1693: 0x0100, 0x1694: 0x0100, 0x1695: 0x0100, 0x1696: 0x0100, 0x1697: 0x0100, 0x1698: 0x0100, 0x1699: 0x0100, 0x169a: 0x0100, 0x169b: 0x0100, 0x169c: 0x0100, 0x169d: 0x0100, 0x169e: 0x0100, 0x169f: 0x0100, 0x16a0: 0x0100, 0x16a1: 0x0100, 0x16a2: 0x0100, 0x16a3: 0x0100, 0x16a4: 0x0100, 0x16a5: 0x0100, 0x16a6: 0x0100, 0x16a7: 0x0100, 0x16a8: 0x0100, 0x16a9: 0x0100, 0x16aa: 0x0100, 0x16ab: 0x0100, 0x16b0: 0x0100, 0x16b1: 0x0100, 0x16b2: 0x0100, 0x16b3: 0x0100, 0x16b4: 0x0100, 0x16b5: 0x0100, 0x16b6: 0x0100, 0x16b7: 0x0100, 0x16b8: 0x0100, 0x16b9: 0x0100, 0x16ba: 0x0100, 0x16bb: 0x0100, 0x16bc: 0x0100, 0x16bd: 0x0100, 0x16be: 0x0100, 0x16bf: 0x0100, // Block 0x5b, offset 0x16c0 0x16c0: 0x0100, 0x16c1: 0x0100, 0x16c2: 0x0100, 0x16c3: 0x0100, 0x16c4: 0x0100, 0x16c5: 0x0100, 0x16c6: 0x0100, 0x16c7: 0x0100, 0x16c8: 0x0100, 0x16c9: 0x0100, 0x16d0: 0x0080, 0x16d1: 0x0080, 0x16d2: 0x0080, 0x16d3: 0x0080, 0x16d4: 0x0080, 0x16d5: 0x0080, 0x16d6: 0x0080, 0x16d7: 0x0080, 0x16d8: 0x0080, 0x16d9: 0x0080, 0x16da: 0x0080, // Block 0x5c, offset 0x1700 0x1700: 0x0100, 0x1701: 0x0100, 0x1702: 0x0100, 0x1703: 0x0100, 0x1704: 0x0100, 0x1705: 0x0100, 0x1706: 0x0100, 0x1707: 0x0100, 0x1708: 0x0100, 0x1709: 0x0100, 0x170a: 0x0100, 0x170b: 0x0100, 0x170c: 0x0100, 0x170d: 0x0100, 0x170e: 0x0100, 0x170f: 0x0100, 0x1710: 0x0100, 0x1711: 0x0100, 0x1712: 0x0100, 0x1713: 0x0100, 0x1714: 0x0100, 0x1715: 0x0100, 0x1716: 0x0100, 0x1717: 0x0008, 0x1718: 0x0008, 0x1719: 0x0008, 0x171a: 0x0008, 0x171b: 0x0008, 0x1720: 0x0100, 0x1721: 0x0100, 0x1722: 0x0100, 0x1723: 0x0100, 0x1724: 0x0100, 0x1725: 0x0100, 0x1726: 0x0100, 0x1727: 0x0100, 0x1728: 0x0100, 0x1729: 0x0100, 0x172a: 0x0100, 0x172b: 0x0100, 0x172c: 0x0100, 0x172d: 0x0100, 0x172e: 0x0100, 0x172f: 0x0100, 0x1730: 0x0100, 0x1731: 0x0100, 0x1732: 0x0100, 0x1733: 0x0100, 0x1734: 0x0100, 0x1735: 0x0100, 0x1736: 0x0100, 0x1737: 0x0100, 0x1738: 0x0100, 0x1739: 0x0100, 0x173a: 0x0100, 0x173b: 0x0100, 0x173c: 0x0100, 0x173d: 0x0100, 0x173e: 0x0100, 0x173f: 0x0100, // Block 0x5d, offset 0x1740 0x1740: 0x0100, 0x1741: 0x0100, 0x1742: 0x0100, 0x1743: 0x0100, 0x1744: 0x0100, 0x1745: 0x0100, 0x1746: 0x0100, 0x1747: 0x0100, 0x1748: 0x0100, 0x1749: 0x0100, 0x174a: 0x0100, 0x174b: 0x0100, 0x174c: 0x0100, 0x174d: 0x0100, 0x174e: 0x0100, 0x174f: 0x0100, 0x1750: 0x0100, 0x1751: 0x0100, 0x1752: 0x0100, 0x1753: 0x0100, 0x1754: 0x0100, 0x1755: 0x0008, 0x1756: 0x0008, 0x1757: 0x0008, 0x1758: 0x0008, 0x1759: 0x0008, 0x175a: 0x0008, 0x175b: 0x0008, 0x175c: 0x0008, 0x175d: 0x0008, 0x175e: 0x0008, 0x1760: 0x0008, 0x1761: 0x0008, 0x1762: 0x0008, 0x1763: 0x0008, 0x1764: 0x0008, 0x1765: 0x0008, 0x1766: 0x0008, 0x1767: 0x0008, 0x1768: 0x0008, 0x1769: 0x0008, 0x176a: 0x0008, 0x176b: 0x0008, 0x176c: 0x0008, 0x176d: 0x0008, 0x176e: 0x0008, 0x176f: 0x0008, 0x1770: 0x0008, 0x1771: 0x0008, 0x1772: 0x0008, 0x1773: 0x0008, 0x1774: 0x0008, 0x1775: 0x0008, 0x1776: 0x0008, 0x1777: 0x0008, 0x1778: 0x0008, 0x1779: 0x0008, 0x177a: 0x0008, 0x177b: 0x0008, 0x177c: 0x0008, 0x177f: 0x0008, // Block 0x5e, offset 0x1780 0x1780: 0x0080, 0x1781: 0x0080, 0x1782: 0x0080, 0x1783: 0x0080, 0x1784: 0x0080, 0x1785: 0x0080, 0x1786: 0x0080, 0x1787: 0x0080, 0x1788: 0x0080, 0x1789: 0x0080, 0x1790: 0x0080, 0x1791: 0x0080, 0x1792: 0x0080, 0x1793: 0x0080, 0x1794: 0x0080, 0x1795: 0x0080, 0x1796: 0x0080, 0x1797: 0x0080, 0x1798: 0x0080, 0x1799: 0x0080, 0x17a7: 0x0100, 0x17a8: 0x0400, 0x17a9: 0x0400, 0x17aa: 0x0400, 0x17ab: 0x0400, 0x17b0: 0x0008, 0x17b1: 0x0008, 0x17b2: 0x0008, 0x17b3: 0x0008, 0x17b4: 0x0008, 0x17b5: 0x0008, 0x17b6: 0x0008, 0x17b7: 0x0008, 0x17b8: 0x0008, 0x17b9: 0x0008, 0x17ba: 0x0008, 0x17bb: 0x0008, 0x17bc: 0x0008, 0x17bd: 0x0008, 0x17be: 0x0008, 0x17bf: 0x0008, // Block 0x5f, offset 0x17c0 0x17c0: 0x0008, 0x17c1: 0x0008, 0x17c2: 0x0008, 0x17c3: 0x0008, 0x17c4: 0x0008, 0x17c5: 0x0008, 0x17c6: 0x0008, 0x17c7: 0x0008, 0x17c8: 0x0008, 0x17c9: 0x0008, 0x17ca: 0x0008, 0x17cb: 0x0008, 0x17cc: 0x0008, 0x17cd: 0x0008, 0x17ce: 0x0008, 0x17cf: 0x0008, 0x17d0: 0x0008, 0x17d1: 0x0008, 0x17d2: 0x0008, 0x17d3: 0x0008, 0x17d4: 0x0008, 0x17d5: 0x0008, 0x17d6: 0x0008, 0x17d7: 0x0008, 0x17d8: 0x0008, 0x17d9: 0x0008, 0x17da: 0x0008, 0x17db: 0x0008, 0x17dc: 0x0008, 0x17dd: 0x0008, 0x17e0: 0x0008, 0x17e1: 0x0008, 0x17e2: 0x0008, 0x17e3: 0x0008, 0x17e4: 0x0008, 0x17e5: 0x0008, 0x17e6: 0x0008, 0x17e7: 0x0008, 0x17e8: 0x0008, 0x17e9: 0x0008, 0x17ea: 0x0008, 0x17eb: 0x0008, // Block 0x60, offset 0x1800 0x1800: 0x0008, 0x1801: 0x0008, 0x1802: 0x0008, 0x1803: 0x0008, 0x1804: 0x0008, 0x1805: 0x0100, 0x1806: 0x0100, 0x1807: 0x0100, 0x1808: 0x0100, 0x1809: 0x0100, 0x180a: 0x0100, 0x180b: 0x0100, 0x180c: 0x0100, 0x180d: 0x0100, 0x180e: 0x0100, 0x180f: 0x0100, 0x1810: 0x0100, 0x1811: 0x0100, 0x1812: 0x0100, 0x1813: 0x0100, 0x1814: 0x0100, 0x1815: 0x0100, 0x1816: 0x0100, 0x1817: 0x0100, 0x1818: 0x0100, 0x1819: 0x0100, 0x181a: 0x0100, 0x181b: 0x0100, 0x181c: 0x0100, 0x181d: 0x0100, 0x181e: 0x0100, 0x181f: 0x0100, 0x1820: 0x0100, 0x1821: 0x0100, 0x1822: 0x0100, 0x1823: 0x0100, 0x1824: 0x0100, 0x1825: 0x0100, 0x1826: 0x0100, 0x1827: 0x0100, 0x1828: 0x0100, 0x1829: 0x0100, 0x182a: 0x0100, 0x182b: 0x0100, 0x182c: 0x0100, 0x182d: 0x0100, 0x182e: 0x0100, 0x182f: 0x0100, 0x1830: 0x0100, 0x1831: 0x0100, 0x1832: 0x0100, 0x1833: 0x0100, 0x1834: 0x0008, 0x1835: 0x0008, 0x1836: 0x0008, 0x1837: 0x0008, 0x1838: 0x0008, 0x1839: 0x0008, 0x183a: 0x0008, 0x183b: 0x0008, 0x183c: 0x0008, 0x183d: 0x0008, 0x183e: 0x0008, 0x183f: 0x0008, // Block 0x61, offset 0x1840 0x1840: 0x0008, 0x1841: 0x0008, 0x1842: 0x0008, 0x1843: 0x0008, 0x1844: 0x0008, 0x1845: 0x0100, 0x1846: 0x0100, 0x1847: 0x0100, 0x1848: 0x0100, 0x1849: 0x0100, 0x184a: 0x0100, 0x184b: 0x0100, 0x184c: 0x0100, 0x184e: 0x0400, 0x184f: 0x0400, 0x1850: 0x0080, 0x1851: 0x0080, 0x1852: 0x0080, 0x1853: 0x0080, 0x1854: 0x0080, 0x1855: 0x0080, 0x1856: 0x0080, 0x1857: 0x0080, 0x1858: 0x0080, 0x1859: 0x0080, 0x185a: 0x0400, 0x185b: 0x0400, 0x185e: 0x0400, 0x185f: 0x0400, 0x186b: 0x0008, 0x186c: 0x0008, 0x186d: 0x0008, 0x186e: 0x0008, 0x186f: 0x0008, 0x1870: 0x0008, 0x1871: 0x0008, 0x1872: 0x0008, 0x1873: 0x0008, 0x187d: 0x0400, 0x187e: 0x0400, 0x187f: 0x0400, // Block 0x62, offset 0x1880 0x1880: 0x0008, 0x1881: 0x0008, 0x1882: 0x0008, 0x1883: 0x0100, 0x1884: 0x0100, 0x1885: 0x0100, 0x1886: 0x0100, 0x1887: 0x0100, 0x1888: 0x0100, 0x1889: 0x0100, 0x188a: 0x0100, 0x188b: 0x0100, 0x188c: 0x0100, 0x188d: 0x0100, 0x188e: 0x0100, 0x188f: 0x0100, 0x1890: 0x0100, 0x1891: 0x0100, 0x1892: 0x0100, 0x1893: 0x0100, 0x1894: 0x0100, 0x1895: 0x0100, 0x1896: 0x0100, 0x1897: 0x0100, 0x1898: 0x0100, 0x1899: 0x0100, 0x189a: 0x0100, 0x189b: 0x0100, 0x189c: 0x0100, 0x189d: 0x0100, 0x189e: 0x0100, 0x189f: 0x0100, 0x18a0: 0x0100, 0x18a1: 0x0008, 0x18a2: 0x0008, 0x18a3: 0x0008, 0x18a4: 0x0008, 0x18a5: 0x0008, 0x18a6: 0x0008, 0x18a7: 0x0008, 0x18a8: 0x0008, 0x18a9: 0x0008, 0x18aa: 0x0008, 0x18ab: 0x0008, 0x18ac: 0x0008, 0x18ad: 0x0008, 0x18ae: 0x0100, 0x18af: 0x0100, 0x18b0: 0x0080, 0x18b1: 0x0080, 0x18b2: 0x0080, 0x18b3: 0x0080, 0x18b4: 0x0080, 0x18b5: 0x0080, 0x18b6: 0x0080, 0x18b7: 0x0080, 0x18b8: 0x0080, 0x18b9: 0x0080, 0x18ba: 0x0100, 0x18bb: 0x0100, 0x18bc: 0x0100, 0x18bd: 0x0100, 0x18be: 0x0100, 0x18bf: 0x0100, // Block 0x63, offset 0x18c0 0x18c0: 0x0100, 0x18c1: 0x0100, 0x18c2: 0x0100, 0x18c3: 0x0100, 0x18c4: 0x0100, 0x18c5: 0x0100, 0x18c6: 0x0100, 0x18c7: 0x0100, 0x18c8: 0x0100, 0x18c9: 0x0100, 0x18ca: 0x0100, 0x18cb: 0x0100, 0x18cc: 0x0100, 0x18cd: 0x0100, 0x18ce: 0x0100, 0x18cf: 0x0100, 0x18d0: 0x0100, 0x18d1: 0x0100, 0x18d2: 0x0100, 0x18d3: 0x0100, 0x18d4: 0x0100, 0x18d5: 0x0100, 0x18d6: 0x0100, 0x18d7: 0x0100, 0x18d8: 0x0100, 0x18d9: 0x0100, 0x18da: 0x0100, 0x18db: 0x0100, 0x18dc: 0x0100, 0x18dd: 0x0100, 0x18de: 0x0100, 0x18df: 0x0100, 0x18e0: 0x0100, 0x18e1: 0x0100, 0x18e2: 0x0100, 0x18e3: 0x0100, 0x18e4: 0x0100, 0x18e5: 0x0100, 0x18e6: 0x0008, 0x18e7: 0x0008, 0x18e8: 0x0008, 0x18e9: 0x0008, 0x18ea: 0x0008, 0x18eb: 0x0008, 0x18ec: 0x0008, 0x18ed: 0x0008, 0x18ee: 0x0008, 0x18ef: 0x0008, 0x18f0: 0x0008, 0x18f1: 0x0008, 0x18f2: 0x0008, 0x18f3: 0x0008, // Block 0x64, offset 0x1900 0x1900: 0x0100, 0x1901: 0x0100, 0x1902: 0x0100, 0x1903: 0x0100, 0x1904: 0x0100, 0x1905: 0x0100, 0x1906: 0x0100, 0x1907: 0x0100, 0x1908: 0x0100, 0x1909: 0x0100, 0x190a: 0x0100, 0x190b: 0x0100, 0x190c: 0x0100, 0x190d: 0x0100, 0x190e: 0x0100, 0x190f: 0x0100, 0x1910: 0x0100, 0x1911: 0x0100, 0x1912: 0x0100, 0x1913: 0x0100, 0x1914: 0x0100, 0x1915: 0x0100, 0x1916: 0x0100, 0x1917: 0x0100, 0x1918: 0x0100, 0x1919: 0x0100, 0x191a: 0x0100, 0x191b: 0x0100, 0x191c: 0x0100, 0x191d: 0x0100, 0x191e: 0x0100, 0x191f: 0x0100, 0x1920: 0x0100, 0x1921: 0x0100, 0x1922: 0x0100, 0x1923: 0x0100, 0x1924: 0x0008, 0x1925: 0x0008, 0x1926: 0x0008, 0x1927: 0x0008, 0x1928: 0x0008, 0x1929: 0x0008, 0x192a: 0x0008, 0x192b: 0x0008, 0x192c: 0x0008, 0x192d: 0x0008, 0x192e: 0x0008, 0x192f: 0x0008, 0x1930: 0x0008, 0x1931: 0x0008, 0x1932: 0x0008, 0x1933: 0x0008, 0x1934: 0x0008, 0x1935: 0x0008, 0x1936: 0x0008, 0x1937: 0x0008, 0x193b: 0x0400, 0x193c: 0x0400, // Block 0x65, offset 0x1940 0x1940: 0x0080, 0x1941: 0x0080, 0x1942: 0x0080, 0x1943: 0x0080, 0x1944: 0x0080, 0x1945: 0x0080, 0x1946: 0x0080, 0x1947: 0x0080, 0x1948: 0x0080, 0x1949: 0x0080, 0x194d: 0x0100, 0x194e: 0x0100, 0x194f: 0x0100, 0x1950: 0x0080, 0x1951: 0x0080, 0x1952: 0x0080, 0x1953: 0x0080, 0x1954: 0x0080, 0x1955: 0x0080, 0x1956: 0x0080, 0x1957: 0x0080, 0x1958: 0x0080, 0x1959: 0x0080, 0x195a: 0x0100, 0x195b: 0x0100, 0x195c: 0x0100, 0x195d: 0x0100, 0x195e: 0x0100, 0x195f: 0x0100, 0x1960: 0x0100, 0x1961: 0x0100, 0x1962: 0x0100, 0x1963: 0x0100, 0x1964: 0x0100, 0x1965: 0x0100, 0x1966: 0x0100, 0x1967: 0x0100, 0x1968: 0x0100, 0x1969: 0x0100, 0x196a: 0x0100, 0x196b: 0x0100, 0x196c: 0x0100, 0x196d: 0x0100, 0x196e: 0x0100, 0x196f: 0x0100, 0x1970: 0x0100, 0x1971: 0x0100, 0x1972: 0x0100, 0x1973: 0x0100, 0x1974: 0x0100, 0x1975: 0x0100, 0x1976: 0x0100, 0x1977: 0x0100, 0x1978: 0x0100, 0x1979: 0x0100, 0x197a: 0x0100, 0x197b: 0x0100, 0x197c: 0x0100, 0x197d: 0x0100, 0x197e: 0x0400, 0x197f: 0x0400, // Block 0x66, offset 0x1980 0x1980: 0x0040, 0x1981: 0x0040, 0x1982: 0x0040, 0x1983: 0x0040, 0x1984: 0x0040, 0x1985: 0x0040, 0x1986: 0x0040, 0x1987: 0x0040, 0x1988: 0x0040, 0x1989: 0x2000, 0x198a: 0x0040, 0x1990: 0x0100, 0x1991: 0x0100, 0x1992: 0x0100, 0x1993: 0x0100, 0x1994: 0x0100, 0x1995: 0x0100, 0x1996: 0x0100, 0x1997: 0x0100, 0x1998: 0x0100, 0x1999: 0x0100, 0x199a: 0x0100, 0x199b: 0x0100, 0x199c: 0x0100, 0x199d: 0x0100, 0x199e: 0x0100, 0x199f: 0x0100, 0x19a0: 0x0100, 0x19a1: 0x0100, 0x19a2: 0x0100, 0x19a3: 0x0100, 0x19a4: 0x0100, 0x19a5: 0x0100, 0x19a6: 0x0100, 0x19a7: 0x0100, 0x19a8: 0x0100, 0x19a9: 0x0100, 0x19aa: 0x0100, 0x19ab: 0x0100, 0x19ac: 0x0100, 0x19ad: 0x0100, 0x19ae: 0x0100, 0x19af: 0x0100, 0x19b0: 0x0100, 0x19b1: 0x0100, 0x19b2: 0x0100, 0x19b3: 0x0100, 0x19b4: 0x0100, 0x19b5: 0x0100, 0x19b6: 0x0100, 0x19b7: 0x0100, 0x19b8: 0x0100, 0x19b9: 0x0100, 0x19ba: 0x0100, 0x19bd: 0x0100, 0x19be: 0x0100, 0x19bf: 0x0100, // Block 0x67, offset 0x19c0 0x19d0: 0x0008, 0x19d1: 0x0008, 0x19d2: 0x0008, 0x19d4: 0x0008, 0x19d5: 0x0008, 0x19d6: 0x0008, 0x19d7: 0x0008, 0x19d8: 0x0008, 0x19d9: 0x0008, 0x19da: 0x0008, 0x19db: 0x0008, 0x19dc: 0x0008, 0x19dd: 0x0008, 0x19de: 0x0008, 0x19df: 0x0008, 0x19e0: 0x0008, 0x19e1: 0x0008, 0x19e2: 0x0008, 0x19e3: 0x0008, 0x19e4: 0x0008, 0x19e5: 0x0008, 0x19e6: 0x0008, 0x19e7: 0x0008, 0x19e8: 0x0008, 0x19e9: 0x0100, 0x19ea: 0x0100, 0x19eb: 0x0100, 0x19ec: 0x0100, 0x19ed: 0x0008, 0x19ee: 0x0100, 0x19ef: 0x0100, 0x19f0: 0x0100, 0x19f1: 0x0100, 0x19f2: 0x0100, 0x19f3: 0x0100, 0x19f4: 0x0008, 0x19f5: 0x0100, 0x19f6: 0x0100, 0x19f7: 0x0008, 0x19f8: 0x0008, 0x19f9: 0x0008, 0x19fa: 0x0100, // Block 0x68, offset 0x1a00 0x1a00: 0x0040, 0x1a01: 0x0040, 0x1a02: 0x0040, 0x1a03: 0x0040, 0x1a04: 0x0040, 0x1a05: 0x0040, 0x1a06: 0x0040, 0x1a07: 0x0040, 0x1a08: 0x0040, 0x1a09: 0x0040, 0x1a0a: 0x0040, 0x1a0b: 0x0040, 0x1a0c: 0x0040, 0x1a0d: 0x0040, 0x1a0e: 0x0040, 0x1a0f: 0x0040, 0x1a10: 0x0040, 0x1a11: 0x0040, 0x1a12: 0x0040, 0x1a13: 0x0040, 0x1a14: 0x0040, 0x1a15: 0x0040, 0x1a16: 0x0040, 0x1a17: 0x0040, 0x1a18: 0x0040, 0x1a19: 0x0040, 0x1a1a: 0x0040, 0x1a1b: 0x0040, 0x1a1c: 0x0040, 0x1a1d: 0x0040, 0x1a1e: 0x0040, 0x1a1f: 0x0040, 0x1a20: 0x0040, 0x1a21: 0x0040, 0x1a22: 0x0040, 0x1a23: 0x0040, 0x1a24: 0x0040, 0x1a25: 0x0040, 0x1a26: 0x0040, 0x1a27: 0x0040, 0x1a28: 0x0040, 0x1a29: 0x0040, 0x1a2a: 0x0040, 0x1a2b: 0x0040, 0x1a2c: 0x0040, 0x1a2d: 0x0040, 0x1a2e: 0x0040, 0x1a2f: 0x0040, 0x1a30: 0x0040, 0x1a31: 0x0040, 0x1a32: 0x0040, 0x1a33: 0x0040, 0x1a34: 0x0040, 0x1a35: 0x0040, 0x1a36: 0x0040, 0x1a37: 0x0040, 0x1a38: 0x0040, 0x1a39: 0x0040, 0x1a3a: 0x0040, 0x1a3b: 0x0040, 0x1a3c: 0x0040, 0x1a3d: 0x0040, 0x1a3e: 0x0040, 0x1a3f: 0x0040, // Block 0x69, offset 0x1a40 0x1a40: 0x2000, 0x1a41: 0x0040, 0x1a42: 0x2000, 0x1a43: 0x0040, 0x1a44: 0x2000, 0x1a45: 0x0040, 0x1a46: 0x2000, 0x1a47: 0x0040, 0x1a48: 0x2000, 0x1a49: 0x0040, 0x1a4a: 0x2000, 0x1a4b: 0x0040, 0x1a4c: 0x2000, 0x1a4d: 0x0040, 0x1a4e: 0x2000, 0x1a4f: 0x0040, 0x1a50: 0x2000, 0x1a51: 0x0040, 0x1a52: 0x2000, 0x1a53: 0x0040, 0x1a54: 0x2000, 0x1a55: 0x0040, 0x1a56: 0x2000, 0x1a57: 0x0040, 0x1a58: 0x2000, 0x1a59: 0x0040, 0x1a5a: 0x2000, 0x1a5b: 0x0040, 0x1a5c: 0x2000, 0x1a5d: 0x0040, 0x1a5e: 0x2000, 0x1a5f: 0x0040, 0x1a60: 0x2000, 0x1a61: 0x0040, 0x1a62: 0x2000, 0x1a63: 0x0040, 0x1a64: 0x2000, 0x1a65: 0x0040, 0x1a66: 0x2000, 0x1a67: 0x0040, 0x1a68: 0x2000, 0x1a69: 0x0040, 0x1a6a: 0x2000, 0x1a6b: 0x0040, 0x1a6c: 0x2000, 0x1a6d: 0x0040, 0x1a6e: 0x2000, 0x1a6f: 0x0040, 0x1a70: 0x2000, 0x1a71: 0x0040, 0x1a72: 0x2000, 0x1a73: 0x0040, 0x1a74: 0x2000, 0x1a75: 0x0040, 0x1a76: 0x2000, 0x1a77: 0x0040, 0x1a78: 0x2000, 0x1a79: 0x0040, 0x1a7a: 0x2000, 0x1a7b: 0x0040, 0x1a7c: 0x2000, 0x1a7d: 0x0040, 0x1a7e: 0x2000, 0x1a7f: 0x0040, // Block 0x6a, offset 0x1a80 0x1a80: 0x2000, 0x1a81: 0x0040, 0x1a82: 0x2000, 0x1a83: 0x0040, 0x1a84: 0x2000, 0x1a85: 0x0040, 0x1a86: 0x2000, 0x1a87: 0x0040, 0x1a88: 0x2000, 0x1a89: 0x0040, 0x1a8a: 0x2000, 0x1a8b: 0x0040, 0x1a8c: 0x2000, 0x1a8d: 0x0040, 0x1a8e: 0x2000, 0x1a8f: 0x0040, 0x1a90: 0x2000, 0x1a91: 0x0040, 0x1a92: 0x2000, 0x1a93: 0x0040, 0x1a94: 0x2000, 0x1a95: 0x0040, 0x1a96: 0x0040, 0x1a97: 0x0040, 0x1a98: 0x0040, 0x1a99: 0x0040, 0x1a9a: 0x0040, 0x1a9b: 0x0040, 0x1a9c: 0x0040, 0x1a9d: 0x0040, 0x1a9e: 0x2000, 0x1a9f: 0x0040, 0x1aa0: 0x2000, 0x1aa1: 0x0040, 0x1aa2: 0x2000, 0x1aa3: 0x0040, 0x1aa4: 0x2000, 0x1aa5: 0x0040, 0x1aa6: 0x2000, 0x1aa7: 0x0040, 0x1aa8: 0x2000, 0x1aa9: 0x0040, 0x1aaa: 0x2000, 0x1aab: 0x0040, 0x1aac: 0x2000, 0x1aad: 0x0040, 0x1aae: 0x2000, 0x1aaf: 0x0040, 0x1ab0: 0x2000, 0x1ab1: 0x0040, 0x1ab2: 0x2000, 0x1ab3: 0x0040, 0x1ab4: 0x2000, 0x1ab5: 0x0040, 0x1ab6: 0x2000, 0x1ab7: 0x0040, 0x1ab8: 0x2000, 0x1ab9: 0x0040, 0x1aba: 0x2000, 0x1abb: 0x0040, 0x1abc: 0x2000, 0x1abd: 0x0040, 0x1abe: 0x2000, 0x1abf: 0x0040, // Block 0x6b, offset 0x1ac0 0x1ac0: 0x0040, 0x1ac1: 0x0040, 0x1ac2: 0x0040, 0x1ac3: 0x0040, 0x1ac4: 0x0040, 0x1ac5: 0x0040, 0x1ac6: 0x0040, 0x1ac7: 0x0040, 0x1ac8: 0x2000, 0x1ac9: 0x2000, 0x1aca: 0x2000, 0x1acb: 0x2000, 0x1acc: 0x2000, 0x1acd: 0x2000, 0x1ace: 0x2000, 0x1acf: 0x2000, 0x1ad0: 0x0040, 0x1ad1: 0x0040, 0x1ad2: 0x0040, 0x1ad3: 0x0040, 0x1ad4: 0x0040, 0x1ad5: 0x0040, 0x1ad8: 0x2000, 0x1ad9: 0x2000, 0x1ada: 0x2000, 0x1adb: 0x2000, 0x1adc: 0x2000, 0x1add: 0x2000, 0x1ae0: 0x0040, 0x1ae1: 0x0040, 0x1ae2: 0x0040, 0x1ae3: 0x0040, 0x1ae4: 0x0040, 0x1ae5: 0x0040, 0x1ae6: 0x0040, 0x1ae7: 0x0040, 0x1ae8: 0x2000, 0x1ae9: 0x2000, 0x1aea: 0x2000, 0x1aeb: 0x2000, 0x1aec: 0x2000, 0x1aed: 0x2000, 0x1aee: 0x2000, 0x1aef: 0x2000, 0x1af0: 0x0040, 0x1af1: 0x0040, 0x1af2: 0x0040, 0x1af3: 0x0040, 0x1af4: 0x0040, 0x1af5: 0x0040, 0x1af6: 0x0040, 0x1af7: 0x0040, 0x1af8: 0x2000, 0x1af9: 0x2000, 0x1afa: 0x2000, 0x1afb: 0x2000, 0x1afc: 0x2000, 0x1afd: 0x2000, 0x1afe: 0x2000, 0x1aff: 0x2000, // Block 0x6c, offset 0x1b00 0x1b00: 0x0040, 0x1b01: 0x0040, 0x1b02: 0x0040, 0x1b03: 0x0040, 0x1b04: 0x0040, 0x1b05: 0x0040, 0x1b08: 0x2000, 0x1b09: 0x2000, 0x1b0a: 0x2000, 0x1b0b: 0x2000, 0x1b0c: 0x2000, 0x1b0d: 0x2000, 0x1b10: 0x0040, 0x1b11: 0x0040, 0x1b12: 0x0040, 0x1b13: 0x0040, 0x1b14: 0x0040, 0x1b15: 0x0040, 0x1b16: 0x0040, 0x1b17: 0x0040, 0x1b19: 0x2000, 0x1b1b: 0x2000, 0x1b1d: 0x2000, 0x1b1f: 0x2000, 0x1b20: 0x0040, 0x1b21: 0x0040, 0x1b22: 0x0040, 0x1b23: 0x0040, 0x1b24: 0x0040, 0x1b25: 0x0040, 0x1b26: 0x0040, 0x1b27: 0x0040, 0x1b28: 0x2000, 0x1b29: 0x2000, 0x1b2a: 0x2000, 0x1b2b: 0x2000, 0x1b2c: 0x2000, 0x1b2d: 0x2000, 0x1b2e: 0x2000, 0x1b2f: 0x2000, 0x1b30: 0x0040, 0x1b31: 0x0040, 0x1b32: 0x0040, 0x1b33: 0x0040, 0x1b34: 0x0040, 0x1b35: 0x0040, 0x1b36: 0x0040, 0x1b37: 0x0040, 0x1b38: 0x0040, 0x1b39: 0x0040, 0x1b3a: 0x0040, 0x1b3b: 0x0040, 0x1b3c: 0x0040, 0x1b3d: 0x0040, // Block 0x6d, offset 0x1b40 0x1b40: 0x0040, 0x1b41: 0x0040, 0x1b42: 0x0040, 0x1b43: 0x0040, 0x1b44: 0x0040, 0x1b45: 0x0040, 0x1b46: 0x0040, 0x1b47: 0x0040, 0x1b48: 0x2000, 0x1b49: 0x2000, 0x1b4a: 0x2000, 0x1b4b: 0x2000, 0x1b4c: 0x2000, 0x1b4d: 0x2000, 0x1b4e: 0x2000, 0x1b4f: 0x2000, 0x1b50: 0x0040, 0x1b51: 0x0040, 0x1b52: 0x0040, 0x1b53: 0x0040, 0x1b54: 0x0040, 0x1b55: 0x0040, 0x1b56: 0x0040, 0x1b57: 0x0040, 0x1b58: 0x2000, 0x1b59: 0x2000, 0x1b5a: 0x2000, 0x1b5b: 0x2000, 0x1b5c: 0x2000, 0x1b5d: 0x2000, 0x1b5e: 0x2000, 0x1b5f: 0x2000, 0x1b60: 0x0040, 0x1b61: 0x0040, 0x1b62: 0x0040, 0x1b63: 0x0040, 0x1b64: 0x0040, 0x1b65: 0x0040, 0x1b66: 0x0040, 0x1b67: 0x0040, 0x1b68: 0x2000, 0x1b69: 0x2000, 0x1b6a: 0x2000, 0x1b6b: 0x2000, 0x1b6c: 0x2000, 0x1b6d: 0x2000, 0x1b6e: 0x2000, 0x1b6f: 0x2000, 0x1b70: 0x0040, 0x1b71: 0x0040, 0x1b72: 0x0040, 0x1b73: 0x0040, 0x1b74: 0x0040, 0x1b76: 0x0040, 0x1b77: 0x0040, 0x1b78: 0x2000, 0x1b79: 0x2000, 0x1b7a: 0x2000, 0x1b7b: 0x2000, 0x1b7c: 0x2000, 0x1b7e: 0x0040, // Block 0x6e, offset 0x1b80 0x1b82: 0x0040, 0x1b83: 0x0040, 0x1b84: 0x0040, 0x1b86: 0x0040, 0x1b87: 0x0040, 0x1b88: 0x2000, 0x1b89: 0x2000, 0x1b8a: 0x2000, 0x1b8b: 0x2000, 0x1b8c: 0x2000, 0x1b90: 0x0040, 0x1b91: 0x0040, 0x1b92: 0x0040, 0x1b93: 0x0040, 0x1b96: 0x0040, 0x1b97: 0x0040, 0x1b98: 0x2000, 0x1b99: 0x2000, 0x1b9a: 0x2000, 0x1b9b: 0x2000, 0x1ba0: 0x0040, 0x1ba1: 0x0040, 0x1ba2: 0x0040, 0x1ba3: 0x0040, 0x1ba4: 0x0040, 0x1ba5: 0x0040, 0x1ba6: 0x0040, 0x1ba7: 0x0040, 0x1ba8: 0x2000, 0x1ba9: 0x2000, 0x1baa: 0x2000, 0x1bab: 0x2000, 0x1bac: 0x2000, 0x1bb2: 0x0040, 0x1bb3: 0x0040, 0x1bb4: 0x0040, 0x1bb6: 0x0040, 0x1bb7: 0x0040, 0x1bb8: 0x2000, 0x1bb9: 0x2000, 0x1bba: 0x2000, 0x1bbb: 0x2000, 0x1bbc: 0x2000, // Block 0x6f, offset 0x1bc0 0x1bc0: 0x1000, 0x1bc1: 0x1000, 0x1bc2: 0x1000, 0x1bc3: 0x1000, 0x1bc4: 0x1000, 0x1bc5: 0x1000, 0x1bc6: 0x1000, 0x1bc7: 0x1000, 0x1bc8: 0x1000, 0x1bc9: 0x1000, 0x1bca: 0x1000, 0x1bcb: 0x0010, 0x1bcc: 0x0008, 0x1bcd: 0x0008, 0x1bce: 0x0010, 0x1bcf: 0x0010, 0x1bd3: 0x0200, 0x1bd4: 0x0200, 0x1bd8: 0x0004, 0x1bd9: 0x0004, 0x1bda: 0x0004, 0x1bdb: 0x0004, 0x1bdc: 0x0004, 0x1bdd: 0x0004, 0x1bde: 0x0004, 0x1bdf: 0x0004, 0x1be4: 0x0001, 0x1be8: 0x0800, 0x1be9: 0x0800, 0x1bea: 0x0010, 0x1beb: 0x0010, 0x1bec: 0x0010, 0x1bed: 0x0010, 0x1bee: 0x0010, 0x1bef: 0x1000, 0x1bf9: 0x0004, 0x1bfa: 0x0004, 0x1bfc: 0x0400, 0x1bfd: 0x0400, // Block 0x70, offset 0x1c00 0x1c05: 0x0004, 0x1c06: 0x0004, 0x1c07: 0x0400, 0x1c08: 0x0400, 0x1c09: 0x0400, 0x1c1f: 0x1000, 0x1c20: 0x0010, 0x1c21: 0x0010, 0x1c22: 0x0010, 0x1c23: 0x0010, 0x1c24: 0x0010, 0x1c26: 0x0010, 0x1c27: 0x0010, 0x1c28: 0x0010, 0x1c29: 0x0010, 0x1c2a: 0x0010, 0x1c2b: 0x0010, 0x1c2c: 0x0010, 0x1c2d: 0x0010, 0x1c2e: 0x0010, 0x1c2f: 0x0010, 0x1c31: 0x0040, 0x1c3d: 0x0004, 0x1c3e: 0x0004, 0x1c3f: 0x0040, // Block 0x71, offset 0x1c40 0x1c4d: 0x0004, 0x1c4e: 0x0004, 0x1c50: 0x0040, 0x1c51: 0x0040, 0x1c52: 0x0040, 0x1c53: 0x0040, 0x1c54: 0x0040, 0x1c55: 0x0040, 0x1c56: 0x0040, 0x1c57: 0x0040, 0x1c58: 0x0040, 0x1c59: 0x0040, 0x1c5a: 0x0040, 0x1c5b: 0x0040, 0x1c5c: 0x0040, // Block 0x72, offset 0x1c80 0x1c90: 0x0008, 0x1c91: 0x0008, 0x1c92: 0x0008, 0x1c93: 0x0008, 0x1c94: 0x0008, 0x1c95: 0x0008, 0x1c96: 0x0008, 0x1c97: 0x0008, 0x1c98: 0x0008, 0x1c99: 0x0008, 0x1c9a: 0x0008, 0x1c9b: 0x0008, 0x1c9c: 0x0008, 0x1c9d: 0x0008, 0x1c9e: 0x0008, 0x1c9f: 0x0008, 0x1ca0: 0x0008, 0x1ca1: 0x0008, 0x1ca2: 0x0008, 0x1ca3: 0x0008, 0x1ca4: 0x0008, 0x1ca5: 0x0008, 0x1ca6: 0x0008, 0x1ca7: 0x0008, 0x1ca8: 0x0008, 0x1ca9: 0x0008, 0x1caa: 0x0008, 0x1cab: 0x0008, 0x1cac: 0x0008, 0x1cad: 0x0008, 0x1cae: 0x0008, 0x1caf: 0x0008, 0x1cb0: 0x0008, // Block 0x73, offset 0x1cc0 0x1cc2: 0x2000, 0x1cc7: 0x2000, 0x1cca: 0x0040, 0x1ccb: 0x2000, 0x1ccc: 0x2000, 0x1ccd: 0x2000, 0x1cce: 0x0040, 0x1ccf: 0x0040, 0x1cd0: 0x2000, 0x1cd1: 0x2000, 0x1cd2: 0x2000, 0x1cd3: 0x0040, 0x1cd5: 0x2000, 0x1cd9: 0x2000, 0x1cda: 0x2000, 0x1cdb: 0x2000, 0x1cdc: 0x2000, 0x1cdd: 0x2000, 0x1ce4: 0x2000, 0x1ce6: 0x2000, 0x1ce8: 0x2000, 0x1cea: 0x2000, 0x1ceb: 0x2000, 0x1cec: 0x2000, 0x1ced: 0x2000, 0x1cef: 0x0040, 0x1cf0: 0x2000, 0x1cf1: 0x2000, 0x1cf2: 0x2000, 0x1cf3: 0x2000, 0x1cf4: 0x0040, 0x1cf5: 0x0100, 0x1cf6: 0x0100, 0x1cf7: 0x0100, 0x1cf8: 0x0100, 0x1cf9: 0x0040, 0x1cfc: 0x0040, 0x1cfd: 0x0040, 0x1cfe: 0x2000, 0x1cff: 0x2000, // Block 0x74, offset 0x1d00 0x1d05: 0x2000, 0x1d06: 0x0040, 0x1d07: 0x0040, 0x1d08: 0x0040, 0x1d09: 0x0040, 0x1d0e: 0x0040, 0x1d20: 0x2000, 0x1d21: 0x2000, 0x1d22: 0x2000, 0x1d23: 0x2000, 0x1d24: 0x2000, 0x1d25: 0x2000, 0x1d26: 0x2000, 0x1d27: 0x2000, 0x1d28: 0x2000, 0x1d29: 0x2000, 0x1d2a: 0x2000, 0x1d2b: 0x2000, 0x1d2c: 0x2000, 0x1d2d: 0x2000, 0x1d2e: 0x2000, 0x1d2f: 0x2000, 0x1d30: 0x0040, 0x1d31: 0x0040, 0x1d32: 0x0040, 0x1d33: 0x0040, 0x1d34: 0x0040, 0x1d35: 0x0040, 0x1d36: 0x0040, 0x1d37: 0x0040, 0x1d38: 0x0040, 0x1d39: 0x0040, 0x1d3a: 0x0040, 0x1d3b: 0x0040, 0x1d3c: 0x0040, 0x1d3d: 0x0040, 0x1d3e: 0x0040, 0x1d3f: 0x0040, // Block 0x75, offset 0x1d40 0x1d40: 0x0100, 0x1d41: 0x0100, 0x1d42: 0x0100, 0x1d43: 0x2000, 0x1d44: 0x0040, 0x1d45: 0x0100, 0x1d46: 0x0100, 0x1d47: 0x0100, 0x1d48: 0x0100, // Block 0x76, offset 0x1d80 0x1d88: 0x0004, 0x1d89: 0x0004, 0x1d8a: 0x0004, 0x1d8b: 0x0004, 0x1da9: 0x0004, 0x1daa: 0x0004, // Block 0x77, offset 0x1dc0 0x1df6: 0x2000, 0x1df7: 0x2000, 0x1df8: 0x2000, 0x1df9: 0x2000, 0x1dfa: 0x2000, 0x1dfb: 0x2000, 0x1dfc: 0x2000, 0x1dfd: 0x2000, 0x1dfe: 0x2000, 0x1dff: 0x2000, // Block 0x78, offset 0x1e00 0x1e00: 0x2000, 0x1e01: 0x2000, 0x1e02: 0x2000, 0x1e03: 0x2000, 0x1e04: 0x2000, 0x1e05: 0x2000, 0x1e06: 0x2000, 0x1e07: 0x2000, 0x1e08: 0x2000, 0x1e09: 0x2000, 0x1e0a: 0x2000, 0x1e0b: 0x2000, 0x1e0c: 0x2000, 0x1e0d: 0x2000, 0x1e0e: 0x2000, 0x1e0f: 0x2000, 0x1e10: 0x0040, 0x1e11: 0x0040, 0x1e12: 0x0040, 0x1e13: 0x0040, 0x1e14: 0x0040, 0x1e15: 0x0040, 0x1e16: 0x0040, 0x1e17: 0x0040, 0x1e18: 0x0040, 0x1e19: 0x0040, 0x1e1a: 0x0040, 0x1e1b: 0x0040, 0x1e1c: 0x0040, 0x1e1d: 0x0040, 0x1e1e: 0x0040, 0x1e1f: 0x0040, 0x1e20: 0x0040, 0x1e21: 0x0040, 0x1e22: 0x0040, 0x1e23: 0x0040, 0x1e24: 0x0040, 0x1e25: 0x0040, 0x1e26: 0x0040, 0x1e27: 0x0040, 0x1e28: 0x0040, 0x1e29: 0x0040, // Block 0x79, offset 0x1e40 0x1e5b: 0x0004, 0x1e5c: 0x0004, 0x1e5d: 0x0004, 0x1e5e: 0x0004, 0x1e5f: 0x0004, 0x1e60: 0x0004, 0x1e68: 0x0004, 0x1e69: 0x0004, 0x1e6a: 0x0004, 0x1e6b: 0x0004, 0x1e6c: 0x0004, 0x1e6d: 0x0004, 0x1e6e: 0x0004, 0x1e6f: 0x0004, 0x1e70: 0x0004, 0x1e71: 0x0004, 0x1e72: 0x0004, 0x1e73: 0x0004, 0x1e74: 0x0004, 0x1e75: 0x0004, // Block 0x7a, offset 0x1e80 0x1e85: 0x0004, 0x1e86: 0x0004, 0x1ea6: 0x0004, 0x1ea7: 0x0004, 0x1ea8: 0x0004, 0x1ea9: 0x0004, 0x1eaa: 0x0004, 0x1eab: 0x0004, 0x1eac: 0x0004, 0x1ead: 0x0004, 0x1eae: 0x0004, 0x1eaf: 0x0004, // Block 0x7b, offset 0x1ec0 0x1ec3: 0x0004, 0x1ec4: 0x0004, 0x1ec5: 0x0004, 0x1ec6: 0x0004, 0x1ec7: 0x0004, 0x1ec8: 0x0004, 0x1ec9: 0x0004, 0x1eca: 0x0004, 0x1ecb: 0x0004, 0x1ecc: 0x0004, 0x1ecd: 0x0004, 0x1ece: 0x0004, 0x1ecf: 0x0004, 0x1ed0: 0x0004, 0x1ed1: 0x0004, 0x1ed2: 0x0004, 0x1ed3: 0x0004, 0x1ed4: 0x0004, 0x1ed5: 0x0004, 0x1ed6: 0x0004, 0x1ed7: 0x0004, 0x1ed8: 0x0004, // Block 0x7c, offset 0x1f00 0x1f18: 0x0004, 0x1f19: 0x0004, 0x1f1a: 0x0004, 0x1f1b: 0x0004, 0x1f3c: 0x0004, 0x1f3d: 0x0004, // Block 0x7d, offset 0x1f40 0x1f40: 0x0040, 0x1f41: 0x0040, 0x1f42: 0x0040, 0x1f43: 0x0040, 0x1f44: 0x0040, 0x1f45: 0x0040, 0x1f46: 0x0040, 0x1f47: 0x0040, 0x1f48: 0x0040, 0x1f49: 0x0040, 0x1f4a: 0x0040, 0x1f4b: 0x0040, 0x1f4c: 0x0040, 0x1f4d: 0x0040, 0x1f4e: 0x0040, 0x1f4f: 0x0040, 0x1f50: 0x0040, 0x1f51: 0x0040, 0x1f52: 0x0040, 0x1f53: 0x0040, 0x1f54: 0x0040, 0x1f55: 0x0040, 0x1f56: 0x0040, 0x1f57: 0x0040, 0x1f58: 0x0040, 0x1f59: 0x0040, 0x1f5a: 0x0040, 0x1f5b: 0x0040, 0x1f5c: 0x0040, 0x1f5d: 0x0040, 0x1f5e: 0x0040, 0x1f5f: 0x0040, 0x1f60: 0x2000, 0x1f61: 0x0040, 0x1f62: 0x2000, 0x1f63: 0x2000, 0x1f64: 0x2000, 0x1f65: 0x0040, 0x1f66: 0x0040, 0x1f67: 0x2000, 0x1f68: 0x0040, 0x1f69: 0x2000, 0x1f6a: 0x0040, 0x1f6b: 0x2000, 0x1f6c: 0x0040, 0x1f6d: 0x2000, 0x1f6e: 0x2000, 0x1f6f: 0x2000, 0x1f70: 0x2000, 0x1f71: 0x0040, 0x1f72: 0x2000, 0x1f73: 0x0040, 0x1f74: 0x0040, 0x1f75: 0x2000, 0x1f76: 0x0040, 0x1f77: 0x0040, 0x1f78: 0x0040, 0x1f79: 0x0040, 0x1f7a: 0x0040, 0x1f7b: 0x0040, 0x1f7c: 0x0040, 0x1f7d: 0x0040, 0x1f7e: 0x2000, 0x1f7f: 0x2000, // Block 0x7e, offset 0x1f80 0x1f80: 0x2000, 0x1f81: 0x0040, 0x1f82: 0x2000, 0x1f83: 0x0040, 0x1f84: 0x2000, 0x1f85: 0x0040, 0x1f86: 0x2000, 0x1f87: 0x0040, 0x1f88: 0x2000, 0x1f89: 0x0040, 0x1f8a: 0x2000, 0x1f8b: 0x0040, 0x1f8c: 0x2000, 0x1f8d: 0x0040, 0x1f8e: 0x2000, 0x1f8f: 0x0040, 0x1f90: 0x2000, 0x1f91: 0x0040, 0x1f92: 0x2000, 0x1f93: 0x0040, 0x1f94: 0x2000, 0x1f95: 0x0040, 0x1f96: 0x2000, 0x1f97: 0x0040, 0x1f98: 0x2000, 0x1f99: 0x0040, 0x1f9a: 0x2000, 0x1f9b: 0x0040, 0x1f9c: 0x2000, 0x1f9d: 0x0040, 0x1f9e: 0x2000, 0x1f9f: 0x0040, 0x1fa0: 0x2000, 0x1fa1: 0x0040, 0x1fa2: 0x2000, 0x1fa3: 0x0040, 0x1fa4: 0x0040, 0x1fab: 0x2000, 0x1fac: 0x0040, 0x1fad: 0x2000, 0x1fae: 0x0040, 0x1faf: 0x0008, 0x1fb0: 0x0008, 0x1fb1: 0x0008, 0x1fb2: 0x2000, 0x1fb3: 0x0040, 0x1fb9: 0x0400, 0x1fba: 0x0400, 0x1fbb: 0x0400, // Block 0x7f, offset 0x1fc0 0x1fc0: 0x0040, 0x1fc1: 0x0040, 0x1fc2: 0x0040, 0x1fc3: 0x0040, 0x1fc4: 0x0040, 0x1fc5: 0x0040, 0x1fc6: 0x0040, 0x1fc7: 0x0040, 0x1fc8: 0x0040, 0x1fc9: 0x0040, 0x1fca: 0x0040, 0x1fcb: 0x0040, 0x1fcc: 0x0040, 0x1fcd: 0x0040, 0x1fce: 0x0040, 0x1fcf: 0x0040, 0x1fd0: 0x0040, 0x1fd1: 0x0040, 0x1fd2: 0x0040, 0x1fd3: 0x0040, 0x1fd4: 0x0040, 0x1fd5: 0x0040, 0x1fd6: 0x0040, 0x1fd7: 0x0040, 0x1fd8: 0x0040, 0x1fd9: 0x0040, 0x1fda: 0x0040, 0x1fdb: 0x0040, 0x1fdc: 0x0040, 0x1fdd: 0x0040, 0x1fde: 0x0040, 0x1fdf: 0x0040, 0x1fe0: 0x0040, 0x1fe1: 0x0040, 0x1fe2: 0x0040, 0x1fe3: 0x0040, 0x1fe4: 0x0040, 0x1fe5: 0x0040, 0x1fe7: 0x0040, 0x1fed: 0x0040, 0x1ff0: 0x0100, 0x1ff1: 0x0100, 0x1ff2: 0x0100, 0x1ff3: 0x0100, 0x1ff4: 0x0100, 0x1ff5: 0x0100, 0x1ff6: 0x0100, 0x1ff7: 0x0100, 0x1ff8: 0x0100, 0x1ff9: 0x0100, 0x1ffa: 0x0100, 0x1ffb: 0x0100, 0x1ffc: 0x0100, 0x1ffd: 0x0100, 0x1ffe: 0x0100, 0x1fff: 0x0100, // Block 0x80, offset 0x2000 0x2000: 0x0100, 0x2001: 0x0100, 0x2002: 0x0100, 0x2003: 0x0100, 0x2004: 0x0100, 0x2005: 0x0100, 0x2006: 0x0100, 0x2007: 0x0100, 0x2008: 0x0100, 0x2009: 0x0100, 0x200a: 0x0100, 0x200b: 0x0100, 0x200c: 0x0100, 0x200d: 0x0100, 0x200e: 0x0100, 0x200f: 0x0100, 0x2010: 0x0100, 0x2011: 0x0100, 0x2012: 0x0100, 0x2013: 0x0100, 0x2014: 0x0100, 0x2015: 0x0100, 0x2016: 0x0100, 0x2017: 0x0100, 0x2018: 0x0100, 0x2019: 0x0100, 0x201a: 0x0100, 0x201b: 0x0100, 0x201c: 0x0100, 0x201d: 0x0100, 0x201e: 0x0100, 0x201f: 0x0100, 0x2020: 0x0100, 0x2021: 0x0100, 0x2022: 0x0100, 0x2023: 0x0100, 0x2024: 0x0100, 0x2025: 0x0100, 0x2026: 0x0100, 0x2027: 0x0100, 0x202f: 0x0100, 0x203f: 0x0008, // Block 0x81, offset 0x2040 0x2040: 0x0100, 0x2041: 0x0100, 0x2042: 0x0100, 0x2043: 0x0100, 0x2044: 0x0100, 0x2045: 0x0100, 0x2046: 0x0100, 0x2047: 0x0100, 0x2048: 0x0100, 0x2049: 0x0100, 0x204a: 0x0100, 0x204b: 0x0100, 0x204c: 0x0100, 0x204d: 0x0100, 0x204e: 0x0100, 0x204f: 0x0100, 0x2050: 0x0100, 0x2051: 0x0100, 0x2052: 0x0100, 0x2053: 0x0100, 0x2054: 0x0100, 0x2055: 0x0100, 0x2056: 0x0100, 0x2060: 0x0100, 0x2061: 0x0100, 0x2062: 0x0100, 0x2063: 0x0100, 0x2064: 0x0100, 0x2065: 0x0100, 0x2066: 0x0100, 0x2068: 0x0100, 0x2069: 0x0100, 0x206a: 0x0100, 0x206b: 0x0100, 0x206c: 0x0100, 0x206d: 0x0100, 0x206e: 0x0100, 0x2070: 0x0100, 0x2071: 0x0100, 0x2072: 0x0100, 0x2073: 0x0100, 0x2074: 0x0100, 0x2075: 0x0100, 0x2076: 0x0100, 0x2078: 0x0100, 0x2079: 0x0100, 0x207a: 0x0100, 0x207b: 0x0100, 0x207c: 0x0100, 0x207d: 0x0100, 0x207e: 0x0100, // Block 0x82, offset 0x2080 0x2080: 0x0100, 0x2081: 0x0100, 0x2082: 0x0100, 0x2083: 0x0100, 0x2084: 0x0100, 0x2085: 0x0100, 0x2086: 0x0100, 0x2088: 0x0100, 0x2089: 0x0100, 0x208a: 0x0100, 0x208b: 0x0100, 0x208c: 0x0100, 0x208d: 0x0100, 0x208e: 0x0100, 0x2090: 0x0100, 0x2091: 0x0100, 0x2092: 0x0100, 0x2093: 0x0100, 0x2094: 0x0100, 0x2095: 0x0100, 0x2096: 0x0100, 0x2098: 0x0100, 0x2099: 0x0100, 0x209a: 0x0100, 0x209b: 0x0100, 0x209c: 0x0100, 0x209d: 0x0100, 0x209e: 0x0100, 0x20a0: 0x0008, 0x20a1: 0x0008, 0x20a2: 0x0008, 0x20a3: 0x0008, 0x20a4: 0x0008, 0x20a5: 0x0008, 0x20a6: 0x0008, 0x20a7: 0x0008, 0x20a8: 0x0008, 0x20a9: 0x0008, 0x20aa: 0x0008, 0x20ab: 0x0008, 0x20ac: 0x0008, 0x20ad: 0x0008, 0x20ae: 0x0008, 0x20af: 0x0008, 0x20b0: 0x0008, 0x20b1: 0x0008, 0x20b2: 0x0008, 0x20b3: 0x0008, 0x20b4: 0x0008, 0x20b5: 0x0008, 0x20b6: 0x0008, 0x20b7: 0x0008, 0x20b8: 0x0008, 0x20b9: 0x0008, 0x20ba: 0x0008, 0x20bb: 0x0008, 0x20bc: 0x0008, 0x20bd: 0x0008, 0x20be: 0x0008, 0x20bf: 0x0008, // Block 0x83, offset 0x20c0 0x20c0: 0x0004, 0x20c1: 0x0004, 0x20c2: 0x0004, 0x20c3: 0x0004, 0x20c4: 0x0004, 0x20c5: 0x0004, 0x20c6: 0x0004, 0x20c7: 0x0004, 0x20c8: 0x0004, 0x20c9: 0x0004, 0x20ca: 0x0004, 0x20cb: 0x0004, 0x20cc: 0x0004, 0x20cd: 0x0004, 0x20dc: 0x0004, 0x20dd: 0x0004, 0x20e0: 0x0004, 0x20e1: 0x0004, 0x20e2: 0x0004, 0x20e3: 0x0004, 0x20e4: 0x0004, 0x20e5: 0x0004, 0x20e6: 0x0004, 0x20e7: 0x0004, 0x20e8: 0x0004, 0x20e9: 0x0004, 0x20ee: 0x0400, 0x20ef: 0x0100, 0x20fc: 0x0400, // Block 0x84, offset 0x2100 0x2102: 0x0004, 0x2113: 0x0400, 0x2114: 0x0400, 0x2115: 0x0004, 0x2116: 0x0004, 0x2117: 0x0004, 0x2118: 0x0004, 0x2119: 0x0004, 0x211a: 0x0004, 0x211b: 0x0004, 0x211c: 0x0004, // Block 0x85, offset 0x2140 0x2140: 0x1000, 0x2141: 0x0200, 0x2142: 0x0400, 0x2145: 0x0100, 0x2146: 0x0100, 0x2147: 0x0100, 0x2148: 0x0004, 0x2149: 0x0004, 0x214a: 0x0004, 0x214b: 0x0004, 0x214c: 0x0004, 0x214d: 0x0004, 0x214e: 0x0004, 0x214f: 0x0004, 0x2150: 0x0004, 0x2151: 0x0004, 0x2154: 0x0004, 0x2155: 0x0004, 0x2156: 0x0004, 0x2157: 0x0004, 0x2158: 0x0004, 0x2159: 0x0004, 0x215a: 0x0004, 0x215b: 0x0004, 0x215d: 0x0004, 0x215e: 0x0004, 0x215f: 0x0004, 0x2161: 0x0100, 0x2162: 0x0100, 0x2163: 0x0100, 0x2164: 0x0100, 0x2165: 0x0100, 0x2166: 0x0100, 0x2167: 0x0100, 0x2168: 0x0100, 0x2169: 0x0100, 0x216a: 0x0008, 0x216b: 0x0008, 0x216c: 0x0008, 0x216d: 0x0008, 0x216e: 0x0008, 0x216f: 0x0008, 0x2171: 0x0100, 0x2172: 0x0100, 0x2173: 0x0100, 0x2174: 0x0100, 0x2175: 0x0100, 0x2178: 0x0100, 0x2179: 0x0100, 0x217a: 0x0100, 0x217b: 0x0100, 0x217c: 0x0100, // Block 0x86, offset 0x2180 0x2180: 0x0100, 0x2181: 0x0100, 0x2182: 0x0100, 0x2183: 0x0100, 0x2184: 0x0100, 0x2185: 0x0100, 0x2186: 0x0100, 0x2187: 0x0100, 0x2188: 0x0100, 0x2189: 0x0100, 0x218a: 0x0100, 0x218b: 0x0100, 0x218c: 0x0100, 0x218d: 0x0100, 0x218e: 0x0100, 0x218f: 0x0100, 0x2190: 0x0100, 0x2191: 0x0100, 0x2192: 0x0100, 0x2193: 0x0100, 0x2194: 0x0100, 0x2195: 0x0100, 0x2196: 0x0100, 0x2199: 0x0008, 0x219a: 0x0008, 0x219d: 0x0100, 0x219e: 0x0100, 0x219f: 0x0100, 0x21a1: 0x0100, 0x21a2: 0x0100, 0x21a3: 0x0100, 0x21a4: 0x0100, 0x21a5: 0x0100, 0x21a6: 0x0100, 0x21a7: 0x0100, 0x21a8: 0x0100, 0x21a9: 0x0100, 0x21aa: 0x0100, 0x21ab: 0x0100, 0x21ac: 0x0100, 0x21ad: 0x0100, 0x21ae: 0x0100, 0x21af: 0x0100, 0x21b0: 0x0100, 0x21b1: 0x0100, 0x21b2: 0x0100, 0x21b3: 0x0100, 0x21b4: 0x0100, 0x21b5: 0x0100, 0x21b6: 0x0100, 0x21b7: 0x0100, 0x21b8: 0x0100, 0x21b9: 0x0100, 0x21ba: 0x0100, 0x21bb: 0x0100, 0x21bc: 0x0100, 0x21bd: 0x0100, 0x21be: 0x0100, 0x21bf: 0x0100, // Block 0x87, offset 0x21c0 0x21c0: 0x0100, 0x21c1: 0x0100, 0x21c2: 0x0100, 0x21c3: 0x0100, 0x21c4: 0x0100, 0x21c5: 0x0100, 0x21c6: 0x0100, 0x21c7: 0x0100, 0x21c8: 0x0100, 0x21c9: 0x0100, 0x21ca: 0x0100, 0x21cb: 0x0100, 0x21cc: 0x0100, 0x21cd: 0x0100, 0x21ce: 0x0100, 0x21cf: 0x0100, 0x21d0: 0x0100, 0x21d1: 0x0100, 0x21d2: 0x0100, 0x21d3: 0x0100, 0x21d4: 0x0100, 0x21d5: 0x0100, 0x21d6: 0x0100, 0x21d7: 0x0100, 0x21d8: 0x0100, 0x21d9: 0x0100, 0x21da: 0x0100, 0x21db: 0x0100, 0x21dc: 0x0100, 0x21dd: 0x0100, 0x21de: 0x0100, 0x21df: 0x0100, 0x21e0: 0x0100, 0x21e1: 0x0100, 0x21e2: 0x0100, 0x21e3: 0x0100, 0x21e4: 0x0100, 0x21e5: 0x0100, 0x21e6: 0x0100, 0x21e7: 0x0100, 0x21e8: 0x0100, 0x21e9: 0x0100, 0x21ea: 0x0100, 0x21eb: 0x0100, 0x21ec: 0x0100, 0x21ed: 0x0100, 0x21ee: 0x0100, 0x21ef: 0x0100, 0x21f0: 0x0100, 0x21f1: 0x0100, 0x21f2: 0x0100, 0x21f3: 0x0100, 0x21f4: 0x0100, 0x21f5: 0x0100, 0x21f6: 0x0100, 0x21f7: 0x0100, 0x21f8: 0x0100, 0x21f9: 0x0100, 0x21fa: 0x0100, 0x21fc: 0x0100, 0x21fd: 0x0100, 0x21fe: 0x0100, 0x21ff: 0x0100, // Block 0x88, offset 0x2200 0x2205: 0x0100, 0x2206: 0x0100, 0x2207: 0x0100, 0x2208: 0x0100, 0x2209: 0x0100, 0x220a: 0x0100, 0x220b: 0x0100, 0x220c: 0x0100, 0x220d: 0x0100, 0x220e: 0x0100, 0x220f: 0x0100, 0x2210: 0x0100, 0x2211: 0x0100, 0x2212: 0x0100, 0x2213: 0x0100, 0x2214: 0x0100, 0x2215: 0x0100, 0x2216: 0x0100, 0x2217: 0x0100, 0x2218: 0x0100, 0x2219: 0x0100, 0x221a: 0x0100, 0x221b: 0x0100, 0x221c: 0x0100, 0x221d: 0x0100, 0x221e: 0x0100, 0x221f: 0x0100, 0x2220: 0x0100, 0x2221: 0x0100, 0x2222: 0x0100, 0x2223: 0x0100, 0x2224: 0x0100, 0x2225: 0x0100, 0x2226: 0x0100, 0x2227: 0x0100, 0x2228: 0x0100, 0x2229: 0x0100, 0x222a: 0x0100, 0x222b: 0x0100, 0x222c: 0x0100, 0x222d: 0x0100, 0x222e: 0x0100, 0x222f: 0x0100, 0x2231: 0x0100, 0x2232: 0x0100, 0x2233: 0x0100, 0x2234: 0x0100, 0x2235: 0x0100, 0x2236: 0x0100, 0x2237: 0x0100, 0x2238: 0x0100, 0x2239: 0x0100, 0x223a: 0x0100, 0x223b: 0x0100, 0x223c: 0x0100, 0x223d: 0x0100, 0x223e: 0x0100, 0x223f: 0x0100, // Block 0x89, offset 0x2240 0x2240: 0x0100, 0x2241: 0x0100, 0x2242: 0x0100, 0x2243: 0x0100, 0x2244: 0x0100, 0x2245: 0x0100, 0x2246: 0x0100, 0x2247: 0x0100, 0x2248: 0x0100, 0x2249: 0x0100, 0x224a: 0x0100, 0x224b: 0x0100, 0x224c: 0x0100, 0x224d: 0x0100, 0x224e: 0x0100, 0x2260: 0x0100, 0x2261: 0x0100, 0x2262: 0x0100, 0x2263: 0x0100, 0x2264: 0x0100, 0x2265: 0x0100, 0x2266: 0x0100, 0x2267: 0x0100, 0x2268: 0x0100, 0x2269: 0x0100, 0x226a: 0x0100, 0x226b: 0x0100, 0x226c: 0x0100, 0x226d: 0x0100, 0x226e: 0x0100, 0x226f: 0x0100, 0x2270: 0x0100, 0x2271: 0x0100, 0x2272: 0x0100, 0x2273: 0x0100, 0x2274: 0x0100, 0x2275: 0x0100, 0x2276: 0x0100, 0x2277: 0x0100, 0x2278: 0x0100, 0x2279: 0x0100, 0x227a: 0x0100, 0x227b: 0x0100, 0x227c: 0x0100, 0x227d: 0x0100, 0x227e: 0x0100, 0x227f: 0x0100, // Block 0x8a, offset 0x2280 0x22b0: 0x0100, 0x22b1: 0x0100, 0x22b2: 0x0100, 0x22b3: 0x0100, 0x22b4: 0x0100, 0x22b5: 0x0100, 0x22b6: 0x0100, 0x22b7: 0x0100, 0x22b8: 0x0100, 0x22b9: 0x0100, 0x22ba: 0x0100, 0x22bb: 0x0100, 0x22bc: 0x0100, 0x22bd: 0x0100, 0x22be: 0x0100, 0x22bf: 0x0100, // Block 0x8b, offset 0x22c0 0x22c0: 0x0100, 0x22c1: 0x0100, 0x22c2: 0x0100, 0x22c3: 0x0100, 0x22c4: 0x0100, 0x22c5: 0x0100, 0x22c6: 0x0100, 0x22c7: 0x0100, 0x22c8: 0x0100, 0x22c9: 0x0100, 0x22ca: 0x0100, 0x22cb: 0x0100, 0x22cc: 0x0100, // Block 0x8c, offset 0x2300 0x2310: 0x0100, 0x2311: 0x0100, 0x2312: 0x0100, 0x2313: 0x0100, 0x2314: 0x0100, 0x2315: 0x0100, 0x2316: 0x0100, 0x2317: 0x0100, 0x2318: 0x0100, 0x2319: 0x0100, 0x231a: 0x0100, 0x231b: 0x0100, 0x231c: 0x0100, 0x231d: 0x0100, 0x231e: 0x0100, 0x231f: 0x0100, 0x2320: 0x0100, 0x2321: 0x0100, 0x2322: 0x0100, 0x2323: 0x0100, 0x2324: 0x0100, 0x2325: 0x0100, 0x2326: 0x0100, 0x2327: 0x0100, 0x2328: 0x0100, 0x2329: 0x0100, 0x232a: 0x0100, 0x232b: 0x0100, 0x232c: 0x0100, 0x232d: 0x0100, 0x232e: 0x0100, 0x232f: 0x0100, 0x2330: 0x0100, 0x2331: 0x0100, 0x2332: 0x0100, 0x2333: 0x0100, 0x2334: 0x0100, 0x2335: 0x0100, 0x2336: 0x0100, 0x2337: 0x0100, 0x2338: 0x0100, 0x2339: 0x0100, 0x233a: 0x0100, 0x233b: 0x0100, 0x233c: 0x0100, 0x233d: 0x0100, 0x233f: 0x0400, // Block 0x8d, offset 0x2340 0x2340: 0x0100, 0x2341: 0x0100, 0x2342: 0x0100, 0x2343: 0x0100, 0x2344: 0x0100, 0x2345: 0x0100, 0x2346: 0x0100, 0x2347: 0x0100, 0x2348: 0x0100, 0x2349: 0x0100, 0x234a: 0x0100, 0x234b: 0x0100, 0x234c: 0x0100, 0x234e: 0x0400, 0x234f: 0x0400, 0x2350: 0x0100, 0x2351: 0x0100, 0x2352: 0x0100, 0x2353: 0x0100, 0x2354: 0x0100, 0x2355: 0x0100, 0x2356: 0x0100, 0x2357: 0x0100, 0x2358: 0x0100, 0x2359: 0x0100, 0x235a: 0x0100, 0x235b: 0x0100, 0x235c: 0x0100, 0x235d: 0x0100, 0x235e: 0x0100, 0x235f: 0x0100, 0x2360: 0x0080, 0x2361: 0x0080, 0x2362: 0x0080, 0x2363: 0x0080, 0x2364: 0x0080, 0x2365: 0x0080, 0x2366: 0x0080, 0x2367: 0x0080, 0x2368: 0x0080, 0x2369: 0x0080, 0x236a: 0x0100, 0x236b: 0x0100, // Block 0x8e, offset 0x2380 0x2380: 0x2000, 0x2381: 0x0040, 0x2382: 0x2000, 0x2383: 0x0040, 0x2384: 0x2000, 0x2385: 0x0040, 0x2386: 0x2000, 0x2387: 0x0040, 0x2388: 0x2000, 0x2389: 0x0040, 0x238a: 0x2000, 0x238b: 0x0040, 0x238c: 0x2000, 0x238d: 0x0040, 0x238e: 0x2000, 0x238f: 0x0040, 0x2390: 0x2000, 0x2391: 0x0040, 0x2392: 0x2000, 0x2393: 0x0040, 0x2394: 0x2000, 0x2395: 0x0040, 0x2396: 0x2000, 0x2397: 0x0040, 0x2398: 0x2000, 0x2399: 0x0040, 0x239a: 0x2000, 0x239b: 0x0040, 0x239c: 0x2000, 0x239d: 0x0040, 0x239e: 0x2000, 0x239f: 0x0040, 0x23a0: 0x2000, 0x23a1: 0x0040, 0x23a2: 0x2000, 0x23a3: 0x0040, 0x23a4: 0x2000, 0x23a5: 0x0040, 0x23a6: 0x2000, 0x23a7: 0x0040, 0x23a8: 0x2000, 0x23a9: 0x0040, 0x23aa: 0x2000, 0x23ab: 0x0040, 0x23ac: 0x2000, 0x23ad: 0x0040, 0x23ae: 0x0100, 0x23af: 0x0008, 0x23b0: 0x0008, 0x23b1: 0x0008, 0x23b2: 0x0008, 0x23b4: 0x0008, 0x23b5: 0x0008, 0x23b6: 0x0008, 0x23b7: 0x0008, 0x23b8: 0x0008, 0x23b9: 0x0008, 0x23ba: 0x0008, 0x23bb: 0x0008, 0x23bc: 0x0008, 0x23bd: 0x0008, 0x23bf: 0x0100, // Block 0x8f, offset 0x23c0 0x23c0: 0x2000, 0x23c1: 0x0040, 0x23c2: 0x2000, 0x23c3: 0x0040, 0x23c4: 0x2000, 0x23c5: 0x0040, 0x23c6: 0x2000, 0x23c7: 0x0040, 0x23c8: 0x2000, 0x23c9: 0x0040, 0x23ca: 0x2000, 0x23cb: 0x0040, 0x23cc: 0x2000, 0x23cd: 0x0040, 0x23ce: 0x2000, 0x23cf: 0x0040, 0x23d0: 0x2000, 0x23d1: 0x0040, 0x23d2: 0x2000, 0x23d3: 0x0040, 0x23d4: 0x2000, 0x23d5: 0x0040, 0x23d6: 0x2000, 0x23d7: 0x0040, 0x23d8: 0x2000, 0x23d9: 0x0040, 0x23da: 0x2000, 0x23db: 0x0040, 0x23dc: 0x0040, 0x23dd: 0x0040, 0x23de: 0x0008, 0x23df: 0x0008, 0x23e0: 0x0100, 0x23e1: 0x0100, 0x23e2: 0x0100, 0x23e3: 0x0100, 0x23e4: 0x0100, 0x23e5: 0x0100, 0x23e6: 0x0100, 0x23e7: 0x0100, 0x23e8: 0x0100, 0x23e9: 0x0100, 0x23ea: 0x0100, 0x23eb: 0x0100, 0x23ec: 0x0100, 0x23ed: 0x0100, 0x23ee: 0x0100, 0x23ef: 0x0100, 0x23f0: 0x0100, 0x23f1: 0x0100, 0x23f2: 0x0100, 0x23f3: 0x0100, 0x23f4: 0x0100, 0x23f5: 0x0100, 0x23f6: 0x0100, 0x23f7: 0x0100, 0x23f8: 0x0100, 0x23f9: 0x0100, 0x23fa: 0x0100, 0x23fb: 0x0100, 0x23fc: 0x0100, 0x23fd: 0x0100, 0x23fe: 0x0100, 0x23ff: 0x0100, // Block 0x90, offset 0x2400 0x2400: 0x0100, 0x2401: 0x0100, 0x2402: 0x0100, 0x2403: 0x0100, 0x2404: 0x0100, 0x2405: 0x0100, 0x2406: 0x0100, 0x2407: 0x0100, 0x2408: 0x0100, 0x2409: 0x0100, 0x240a: 0x0100, 0x240b: 0x0100, 0x240c: 0x0100, 0x240d: 0x0100, 0x240e: 0x0100, 0x240f: 0x0100, 0x2410: 0x0100, 0x2411: 0x0100, 0x2412: 0x0100, 0x2413: 0x0100, 0x2414: 0x0100, 0x2415: 0x0100, 0x2416: 0x0100, 0x2417: 0x0100, 0x2418: 0x0100, 0x2419: 0x0100, 0x241a: 0x0100, 0x241b: 0x0100, 0x241c: 0x0100, 0x241d: 0x0100, 0x241e: 0x0100, 0x241f: 0x0100, 0x2420: 0x0100, 0x2421: 0x0100, 0x2422: 0x0100, 0x2423: 0x0100, 0x2424: 0x0100, 0x2425: 0x0100, 0x2426: 0x0100, 0x2427: 0x0100, 0x2428: 0x0100, 0x2429: 0x0100, 0x242a: 0x0100, 0x242b: 0x0100, 0x242c: 0x0100, 0x242d: 0x0100, 0x242e: 0x0100, 0x242f: 0x0100, 0x2430: 0x0008, 0x2431: 0x0008, 0x2433: 0x0400, 0x2437: 0x0400, // Block 0x91, offset 0x2440 0x2457: 0x0100, 0x2458: 0x0100, 0x2459: 0x0100, 0x245a: 0x0100, 0x245b: 0x0100, 0x245c: 0x0100, 0x245d: 0x0100, 0x245e: 0x0100, 0x245f: 0x0100, 0x2462: 0x2000, 0x2463: 0x0040, 0x2464: 0x2000, 0x2465: 0x0040, 0x2466: 0x2000, 0x2467: 0x0040, 0x2468: 0x2000, 0x2469: 0x0040, 0x246a: 0x2000, 0x246b: 0x0040, 0x246c: 0x2000, 0x246d: 0x0040, 0x246e: 0x2000, 0x246f: 0x0040, 0x2470: 0x0040, 0x2471: 0x0040, 0x2472: 0x2000, 0x2473: 0x0040, 0x2474: 0x2000, 0x2475: 0x0040, 0x2476: 0x2000, 0x2477: 0x0040, 0x2478: 0x2000, 0x2479: 0x0040, 0x247a: 0x2000, 0x247b: 0x0040, 0x247c: 0x2000, 0x247d: 0x0040, 0x247e: 0x2000, 0x247f: 0x0040, // Block 0x92, offset 0x2480 0x2480: 0x2000, 0x2481: 0x0040, 0x2482: 0x2000, 0x2483: 0x0040, 0x2484: 0x2000, 0x2485: 0x0040, 0x2486: 0x2000, 0x2487: 0x0040, 0x2488: 0x2000, 0x2489: 0x0040, 0x248a: 0x2000, 0x248b: 0x0040, 0x248c: 0x2000, 0x248d: 0x0040, 0x248e: 0x2000, 0x248f: 0x0040, 0x2490: 0x2000, 0x2491: 0x0040, 0x2492: 0x2000, 0x2493: 0x0040, 0x2494: 0x2000, 0x2495: 0x0040, 0x2496: 0x2000, 0x2497: 0x0040, 0x2498: 0x2000, 0x2499: 0x0040, 0x249a: 0x2000, 0x249b: 0x0040, 0x249c: 0x2000, 0x249d: 0x0040, 0x249e: 0x2000, 0x249f: 0x0040, 0x24a0: 0x2000, 0x24a1: 0x0040, 0x24a2: 0x2000, 0x24a3: 0x0040, 0x24a4: 0x2000, 0x24a5: 0x0040, 0x24a6: 0x2000, 0x24a7: 0x0040, 0x24a8: 0x2000, 0x24a9: 0x0040, 0x24aa: 0x2000, 0x24ab: 0x0040, 0x24ac: 0x2000, 0x24ad: 0x0040, 0x24ae: 0x2000, 0x24af: 0x0040, 0x24b0: 0x0040, 0x24b1: 0x0040, 0x24b2: 0x0040, 0x24b3: 0x0040, 0x24b4: 0x0040, 0x24b5: 0x0040, 0x24b6: 0x0040, 0x24b7: 0x0040, 0x24b8: 0x0040, 0x24b9: 0x2000, 0x24ba: 0x0040, 0x24bb: 0x2000, 0x24bc: 0x0040, 0x24bd: 0x2000, 0x24be: 0x2000, 0x24bf: 0x0040, // Block 0x93, offset 0x24c0 0x24c0: 0x2000, 0x24c1: 0x0040, 0x24c2: 0x2000, 0x24c3: 0x0040, 0x24c4: 0x2000, 0x24c5: 0x0040, 0x24c6: 0x2000, 0x24c7: 0x0040, 0x24c8: 0x0100, 0x24cb: 0x2000, 0x24cc: 0x0040, 0x24cd: 0x2000, 0x24ce: 0x0040, 0x24cf: 0x0100, 0x24d0: 0x2000, 0x24d1: 0x0040, 0x24d2: 0x2000, 0x24d3: 0x0040, 0x24d4: 0x0040, 0x24d5: 0x0040, 0x24d6: 0x2000, 0x24d7: 0x0040, 0x24d8: 0x2000, 0x24d9: 0x0040, 0x24da: 0x2000, 0x24db: 0x0040, 0x24dc: 0x2000, 0x24dd: 0x0040, 0x24de: 0x2000, 0x24df: 0x0040, 0x24e0: 0x2000, 0x24e1: 0x0040, 0x24e2: 0x2000, 0x24e3: 0x0040, 0x24e4: 0x2000, 0x24e5: 0x0040, 0x24e6: 0x2000, 0x24e7: 0x0040, 0x24e8: 0x2000, 0x24e9: 0x0040, 0x24ea: 0x2000, 0x24eb: 0x2000, 0x24ec: 0x2000, 0x24ed: 0x2000, 0x24ee: 0x2000, 0x24ef: 0x0040, 0x24f0: 0x2000, 0x24f1: 0x2000, 0x24f2: 0x2000, 0x24f3: 0x2000, 0x24f4: 0x2000, 0x24f5: 0x0040, 0x24f6: 0x2000, 0x24f7: 0x0040, 0x24f8: 0x2000, 0x24f9: 0x0040, 0x24fa: 0x2000, 0x24fb: 0x0040, 0x24fc: 0x2000, 0x24fd: 0x0040, 0x24fe: 0x2000, 0x24ff: 0x0040, // Block 0x94, offset 0x2500 0x2500: 0x2000, 0x2501: 0x0040, 0x2502: 0x2000, 0x2503: 0x0040, 0x2504: 0x2000, 0x2505: 0x2000, 0x2506: 0x2000, 0x2507: 0x2000, 0x2508: 0x0040, 0x2509: 0x2000, 0x250a: 0x0040, 0x250b: 0x2000, 0x250c: 0x2000, 0x250d: 0x0040, 0x250e: 0x2000, 0x250f: 0x0040, 0x2510: 0x2000, 0x2511: 0x0040, 0x2512: 0x2000, 0x2513: 0x0040, 0x2514: 0x2000, 0x2515: 0x0040, 0x2516: 0x2000, 0x2517: 0x0040, 0x2518: 0x2000, 0x2519: 0x0040, 0x251a: 0x2000, 0x251b: 0x0040, 0x251c: 0x2000, 0x2531: 0x0040, 0x2532: 0x0040, 0x2533: 0x0040, 0x2534: 0x0040, 0x2535: 0x2000, 0x2536: 0x0040, 0x2537: 0x0100, 0x2538: 0x0040, 0x2539: 0x0040, 0x253a: 0x0040, 0x253b: 0x0100, 0x253c: 0x0100, 0x253d: 0x0100, 0x253e: 0x0100, 0x253f: 0x0100, // Block 0x95, offset 0x2540 0x2540: 0x0100, 0x2541: 0x0100, 0x2542: 0x0008, 0x2543: 0x0100, 0x2544: 0x0100, 0x2545: 0x0100, 0x2546: 0x0008, 0x2547: 0x0100, 0x2548: 0x0100, 0x2549: 0x0100, 0x254a: 0x0100, 0x254b: 0x0008, 0x254c: 0x0100, 0x254d: 0x0100, 0x254e: 0x0100, 0x254f: 0x0100, 0x2550: 0x0100, 0x2551: 0x0100, 0x2552: 0x0100, 0x2553: 0x0100, 0x2554: 0x0100, 0x2555: 0x0100, 0x2556: 0x0100, 0x2557: 0x0100, 0x2558: 0x0100, 0x2559: 0x0100, 0x255a: 0x0100, 0x255b: 0x0100, 0x255c: 0x0100, 0x255d: 0x0100, 0x255e: 0x0100, 0x255f: 0x0100, 0x2560: 0x0100, 0x2561: 0x0100, 0x2562: 0x0100, 0x2563: 0x0008, 0x2564: 0x0008, 0x2565: 0x0008, 0x2566: 0x0008, 0x2567: 0x0008, 0x256c: 0x0008, // Block 0x96, offset 0x2580 0x2580: 0x0100, 0x2581: 0x0100, 0x2582: 0x0100, 0x2583: 0x0100, 0x2584: 0x0100, 0x2585: 0x0100, 0x2586: 0x0100, 0x2587: 0x0100, 0x2588: 0x0100, 0x2589: 0x0100, 0x258a: 0x0100, 0x258b: 0x0100, 0x258c: 0x0100, 0x258d: 0x0100, 0x258e: 0x0100, 0x258f: 0x0100, 0x2590: 0x0100, 0x2591: 0x0100, 0x2592: 0x0100, 0x2593: 0x0100, 0x2594: 0x0100, 0x2595: 0x0100, 0x2596: 0x0100, 0x2597: 0x0100, 0x2598: 0x0100, 0x2599: 0x0100, 0x259a: 0x0100, 0x259b: 0x0100, 0x259c: 0x0100, 0x259d: 0x0100, 0x259e: 0x0100, 0x259f: 0x0100, 0x25a0: 0x0100, 0x25a1: 0x0100, 0x25a2: 0x0100, 0x25a3: 0x0100, 0x25a4: 0x0100, 0x25a5: 0x0100, 0x25a6: 0x0100, 0x25a7: 0x0100, 0x25a8: 0x0100, 0x25a9: 0x0100, 0x25aa: 0x0100, 0x25ab: 0x0100, 0x25ac: 0x0100, 0x25ad: 0x0100, 0x25ae: 0x0100, 0x25af: 0x0100, 0x25b0: 0x0100, 0x25b1: 0x0100, 0x25b2: 0x0100, 0x25b3: 0x0100, 0x25b6: 0x0400, 0x25b7: 0x0400, // Block 0x97, offset 0x25c0 0x25c0: 0x0008, 0x25c1: 0x0008, 0x25c2: 0x0100, 0x25c3: 0x0100, 0x25c4: 0x0100, 0x25c5: 0x0100, 0x25c6: 0x0100, 0x25c7: 0x0100, 0x25c8: 0x0100, 0x25c9: 0x0100, 0x25ca: 0x0100, 0x25cb: 0x0100, 0x25cc: 0x0100, 0x25cd: 0x0100, 0x25ce: 0x0100, 0x25cf: 0x0100, 0x25d0: 0x0100, 0x25d1: 0x0100, 0x25d2: 0x0100, 0x25d3: 0x0100, 0x25d4: 0x0100, 0x25d5: 0x0100, 0x25d6: 0x0100, 0x25d7: 0x0100, 0x25d8: 0x0100, 0x25d9: 0x0100, 0x25da: 0x0100, 0x25db: 0x0100, 0x25dc: 0x0100, 0x25dd: 0x0100, 0x25de: 0x0100, 0x25df: 0x0100, 0x25e0: 0x0100, 0x25e1: 0x0100, 0x25e2: 0x0100, 0x25e3: 0x0100, 0x25e4: 0x0100, 0x25e5: 0x0100, 0x25e6: 0x0100, 0x25e7: 0x0100, 0x25e8: 0x0100, 0x25e9: 0x0100, 0x25ea: 0x0100, 0x25eb: 0x0100, 0x25ec: 0x0100, 0x25ed: 0x0100, 0x25ee: 0x0100, 0x25ef: 0x0100, 0x25f0: 0x0100, 0x25f1: 0x0100, 0x25f2: 0x0100, 0x25f3: 0x0100, 0x25f4: 0x0008, 0x25f5: 0x0008, 0x25f6: 0x0008, 0x25f7: 0x0008, 0x25f8: 0x0008, 0x25f9: 0x0008, 0x25fa: 0x0008, 0x25fb: 0x0008, 0x25fc: 0x0008, 0x25fd: 0x0008, 0x25fe: 0x0008, 0x25ff: 0x0008, // Block 0x98, offset 0x2600 0x2600: 0x0008, 0x2601: 0x0008, 0x2602: 0x0008, 0x2603: 0x0008, 0x2604: 0x0008, 0x2605: 0x0008, 0x260e: 0x0400, 0x260f: 0x0400, 0x2610: 0x0080, 0x2611: 0x0080, 0x2612: 0x0080, 0x2613: 0x0080, 0x2614: 0x0080, 0x2615: 0x0080, 0x2616: 0x0080, 0x2617: 0x0080, 0x2618: 0x0080, 0x2619: 0x0080, 0x2620: 0x0008, 0x2621: 0x0008, 0x2622: 0x0008, 0x2623: 0x0008, 0x2624: 0x0008, 0x2625: 0x0008, 0x2626: 0x0008, 0x2627: 0x0008, 0x2628: 0x0008, 0x2629: 0x0008, 0x262a: 0x0008, 0x262b: 0x0008, 0x262c: 0x0008, 0x262d: 0x0008, 0x262e: 0x0008, 0x262f: 0x0008, 0x2630: 0x0008, 0x2631: 0x0008, 0x2632: 0x0100, 0x2633: 0x0100, 0x2634: 0x0100, 0x2635: 0x0100, 0x2636: 0x0100, 0x2637: 0x0100, 0x263b: 0x0100, 0x263d: 0x0100, 0x263e: 0x0100, 0x263f: 0x0008, // Block 0x99, offset 0x2640 0x2640: 0x0080, 0x2641: 0x0080, 0x2642: 0x0080, 0x2643: 0x0080, 0x2644: 0x0080, 0x2645: 0x0080, 0x2646: 0x0080, 0x2647: 0x0080, 0x2648: 0x0080, 0x2649: 0x0080, 0x264a: 0x0100, 0x264b: 0x0100, 0x264c: 0x0100, 0x264d: 0x0100, 0x264e: 0x0100, 0x264f: 0x0100, 0x2650: 0x0100, 0x2651: 0x0100, 0x2652: 0x0100, 0x2653: 0x0100, 0x2654: 0x0100, 0x2655: 0x0100, 0x2656: 0x0100, 0x2657: 0x0100, 0x2658: 0x0100, 0x2659: 0x0100, 0x265a: 0x0100, 0x265b: 0x0100, 0x265c: 0x0100, 0x265d: 0x0100, 0x265e: 0x0100, 0x265f: 0x0100, 0x2660: 0x0100, 0x2661: 0x0100, 0x2662: 0x0100, 0x2663: 0x0100, 0x2664: 0x0100, 0x2665: 0x0100, 0x2666: 0x0008, 0x2667: 0x0008, 0x2668: 0x0008, 0x2669: 0x0008, 0x266a: 0x0008, 0x266b: 0x0008, 0x266c: 0x0008, 0x266d: 0x0008, 0x266f: 0x0400, 0x2670: 0x0100, 0x2671: 0x0100, 0x2672: 0x0100, 0x2673: 0x0100, 0x2674: 0x0100, 0x2675: 0x0100, 0x2676: 0x0100, 0x2677: 0x0100, 0x2678: 0x0100, 0x2679: 0x0100, 0x267a: 0x0100, 0x267b: 0x0100, 0x267c: 0x0100, 0x267d: 0x0100, 0x267e: 0x0100, 0x267f: 0x0100, // Block 0x9a, offset 0x2680 0x2680: 0x0100, 0x2681: 0x0100, 0x2682: 0x0100, 0x2683: 0x0100, 0x2684: 0x0100, 0x2685: 0x0100, 0x2686: 0x0100, 0x2687: 0x0008, 0x2688: 0x0008, 0x2689: 0x0008, 0x268a: 0x0008, 0x268b: 0x0008, 0x268c: 0x0008, 0x268d: 0x0008, 0x268e: 0x0008, 0x268f: 0x0008, 0x2690: 0x0008, 0x2691: 0x0008, 0x2692: 0x0008, 0x2693: 0x0008, 0x26a0: 0x0100, 0x26a1: 0x0100, 0x26a2: 0x0100, 0x26a3: 0x0100, 0x26a4: 0x0100, 0x26a5: 0x0100, 0x26a6: 0x0100, 0x26a7: 0x0100, 0x26a8: 0x0100, 0x26a9: 0x0100, 0x26aa: 0x0100, 0x26ab: 0x0100, 0x26ac: 0x0100, 0x26ad: 0x0100, 0x26ae: 0x0100, 0x26af: 0x0100, 0x26b0: 0x0100, 0x26b1: 0x0100, 0x26b2: 0x0100, 0x26b3: 0x0100, 0x26b4: 0x0100, 0x26b5: 0x0100, 0x26b6: 0x0100, 0x26b7: 0x0100, 0x26b8: 0x0100, 0x26b9: 0x0100, 0x26ba: 0x0100, 0x26bb: 0x0100, 0x26bc: 0x0100, // Block 0x9b, offset 0x26c0 0x26c0: 0x0008, 0x26c1: 0x0008, 0x26c2: 0x0008, 0x26c3: 0x0008, 0x26c4: 0x0100, 0x26c5: 0x0100, 0x26c6: 0x0100, 0x26c7: 0x0100, 0x26c8: 0x0100, 0x26c9: 0x0100, 0x26ca: 0x0100, 0x26cb: 0x0100, 0x26cc: 0x0100, 0x26cd: 0x0100, 0x26ce: 0x0100, 0x26cf: 0x0100, 0x26d0: 0x0100, 0x26d1: 0x0100, 0x26d2: 0x0100, 0x26d3: 0x0100, 0x26d4: 0x0100, 0x26d5: 0x0100, 0x26d6: 0x0100, 0x26d7: 0x0100, 0x26d8: 0x0100, 0x26d9: 0x0100, 0x26da: 0x0100, 0x26db: 0x0100, 0x26dc: 0x0100, 0x26dd: 0x0100, 0x26de: 0x0100, 0x26df: 0x0100, 0x26e0: 0x0100, 0x26e1: 0x0100, 0x26e2: 0x0100, 0x26e3: 0x0100, 0x26e4: 0x0100, 0x26e5: 0x0100, 0x26e6: 0x0100, 0x26e7: 0x0100, 0x26e8: 0x0100, 0x26e9: 0x0100, 0x26ea: 0x0100, 0x26eb: 0x0100, 0x26ec: 0x0100, 0x26ed: 0x0100, 0x26ee: 0x0100, 0x26ef: 0x0100, 0x26f0: 0x0100, 0x26f1: 0x0100, 0x26f2: 0x0100, 0x26f3: 0x0008, 0x26f4: 0x0008, 0x26f5: 0x0008, 0x26f6: 0x0008, 0x26f7: 0x0008, 0x26f8: 0x0008, 0x26f9: 0x0008, 0x26fa: 0x0008, 0x26fb: 0x0008, 0x26fc: 0x0008, 0x26fd: 0x0008, 0x26fe: 0x0008, 0x26ff: 0x0008, // Block 0x9c, offset 0x2700 0x2700: 0x0008, 0x2708: 0x0400, 0x2709: 0x0400, 0x270f: 0x0100, 0x2710: 0x0080, 0x2711: 0x0080, 0x2712: 0x0080, 0x2713: 0x0080, 0x2714: 0x0080, 0x2715: 0x0080, 0x2716: 0x0080, 0x2717: 0x0080, 0x2718: 0x0080, 0x2719: 0x0080, 0x2720: 0x0100, 0x2721: 0x0100, 0x2722: 0x0100, 0x2723: 0x0100, 0x2724: 0x0100, 0x2725: 0x0008, 0x2726: 0x0100, 0x2727: 0x0100, 0x2728: 0x0100, 0x2729: 0x0100, 0x272a: 0x0100, 0x272b: 0x0100, 0x272c: 0x0100, 0x272d: 0x0100, 0x272e: 0x0100, 0x272f: 0x0100, 0x2730: 0x0080, 0x2731: 0x0080, 0x2732: 0x0080, 0x2733: 0x0080, 0x2734: 0x0080, 0x2735: 0x0080, 0x2736: 0x0080, 0x2737: 0x0080, 0x2738: 0x0080, 0x2739: 0x0080, 0x273a: 0x0100, 0x273b: 0x0100, 0x273c: 0x0100, 0x273d: 0x0100, 0x273e: 0x0100, // Block 0x9d, offset 0x2740 0x2740: 0x0100, 0x2741: 0x0100, 0x2742: 0x0100, 0x2743: 0x0100, 0x2744: 0x0100, 0x2745: 0x0100, 0x2746: 0x0100, 0x2747: 0x0100, 0x2748: 0x0100, 0x2749: 0x0100, 0x274a: 0x0100, 0x274b: 0x0100, 0x274c: 0x0100, 0x274d: 0x0100, 0x274e: 0x0100, 0x274f: 0x0100, 0x2750: 0x0100, 0x2751: 0x0100, 0x2752: 0x0100, 0x2753: 0x0100, 0x2754: 0x0100, 0x2755: 0x0100, 0x2756: 0x0100, 0x2757: 0x0100, 0x2758: 0x0100, 0x2759: 0x0100, 0x275a: 0x0100, 0x275b: 0x0100, 0x275c: 0x0100, 0x275d: 0x0100, 0x275e: 0x0100, 0x275f: 0x0100, 0x2760: 0x0100, 0x2761: 0x0100, 0x2762: 0x0100, 0x2763: 0x0100, 0x2764: 0x0100, 0x2765: 0x0100, 0x2766: 0x0100, 0x2767: 0x0100, 0x2768: 0x0100, 0x2769: 0x0008, 0x276a: 0x0008, 0x276b: 0x0008, 0x276c: 0x0008, 0x276d: 0x0008, 0x276e: 0x0008, 0x276f: 0x0008, 0x2770: 0x0008, 0x2771: 0x0008, 0x2772: 0x0008, 0x2773: 0x0008, 0x2774: 0x0008, 0x2775: 0x0008, 0x2776: 0x0008, // Block 0x9e, offset 0x2780 0x2780: 0x0100, 0x2781: 0x0100, 0x2782: 0x0100, 0x2783: 0x0008, 0x2784: 0x0100, 0x2785: 0x0100, 0x2786: 0x0100, 0x2787: 0x0100, 0x2788: 0x0100, 0x2789: 0x0100, 0x278a: 0x0100, 0x278b: 0x0100, 0x278c: 0x0008, 0x278d: 0x0008, 0x2790: 0x0080, 0x2791: 0x0080, 0x2792: 0x0080, 0x2793: 0x0080, 0x2794: 0x0080, 0x2795: 0x0080, 0x2796: 0x0080, 0x2797: 0x0080, 0x2798: 0x0080, 0x2799: 0x0080, 0x279d: 0x0400, 0x279e: 0x0400, 0x279f: 0x0400, 0x27a0: 0x0100, 0x27a1: 0x0100, 0x27a2: 0x0100, 0x27a3: 0x0100, 0x27a4: 0x0100, 0x27a5: 0x0100, 0x27a6: 0x0100, 0x27a7: 0x0100, 0x27a8: 0x0100, 0x27a9: 0x0100, 0x27aa: 0x0100, 0x27ab: 0x0100, 0x27ac: 0x0100, 0x27ad: 0x0100, 0x27ae: 0x0100, 0x27af: 0x0100, 0x27b0: 0x0100, 0x27b1: 0x0100, 0x27b2: 0x0100, 0x27b3: 0x0100, 0x27b4: 0x0100, 0x27b5: 0x0100, 0x27b6: 0x0100, 0x27ba: 0x0100, 0x27bb: 0x0008, 0x27bc: 0x0008, 0x27bd: 0x0008, 0x27be: 0x0100, 0x27bf: 0x0100, // Block 0x9f, offset 0x27c0 0x27c0: 0x0100, 0x27c1: 0x0100, 0x27c2: 0x0100, 0x27c3: 0x0100, 0x27c4: 0x0100, 0x27c5: 0x0100, 0x27c6: 0x0100, 0x27c7: 0x0100, 0x27c8: 0x0100, 0x27c9: 0x0100, 0x27ca: 0x0100, 0x27cb: 0x0100, 0x27cc: 0x0100, 0x27cd: 0x0100, 0x27ce: 0x0100, 0x27cf: 0x0100, 0x27d0: 0x0100, 0x27d1: 0x0100, 0x27d2: 0x0100, 0x27d3: 0x0100, 0x27d4: 0x0100, 0x27d5: 0x0100, 0x27d6: 0x0100, 0x27d7: 0x0100, 0x27d8: 0x0100, 0x27d9: 0x0100, 0x27da: 0x0100, 0x27db: 0x0100, 0x27dc: 0x0100, 0x27dd: 0x0100, 0x27de: 0x0100, 0x27df: 0x0100, 0x27e0: 0x0100, 0x27e1: 0x0100, 0x27e2: 0x0100, 0x27e3: 0x0100, 0x27e4: 0x0100, 0x27e5: 0x0100, 0x27e6: 0x0100, 0x27e7: 0x0100, 0x27e8: 0x0100, 0x27e9: 0x0100, 0x27ea: 0x0100, 0x27eb: 0x0100, 0x27ec: 0x0100, 0x27ed: 0x0100, 0x27ee: 0x0100, 0x27ef: 0x0100, 0x27f0: 0x0008, 0x27f1: 0x0100, 0x27f2: 0x0008, 0x27f3: 0x0008, 0x27f4: 0x0008, 0x27f5: 0x0100, 0x27f6: 0x0100, 0x27f7: 0x0008, 0x27f8: 0x0008, 0x27f9: 0x0100, 0x27fa: 0x0100, 0x27fb: 0x0100, 0x27fc: 0x0100, 0x27fd: 0x0100, 0x27fe: 0x0008, 0x27ff: 0x0008, // Block 0xa0, offset 0x2800 0x2800: 0x0100, 0x2801: 0x0008, 0x2802: 0x0100, 0x281b: 0x0100, 0x281c: 0x0100, 0x281d: 0x0100, 0x2820: 0x0100, 0x2821: 0x0100, 0x2822: 0x0100, 0x2823: 0x0100, 0x2824: 0x0100, 0x2825: 0x0100, 0x2826: 0x0100, 0x2827: 0x0100, 0x2828: 0x0100, 0x2829: 0x0100, 0x282a: 0x0100, 0x282b: 0x0008, 0x282c: 0x0008, 0x282d: 0x0008, 0x282e: 0x0008, 0x282f: 0x0008, 0x2830: 0x0400, 0x2831: 0x0400, 0x2832: 0x0100, 0x2833: 0x0100, 0x2834: 0x0100, 0x2835: 0x0008, 0x2836: 0x0008, // Block 0xa1, offset 0x2840 0x2841: 0x0100, 0x2842: 0x0100, 0x2843: 0x0100, 0x2844: 0x0100, 0x2845: 0x0100, 0x2846: 0x0100, 0x2849: 0x0100, 0x284a: 0x0100, 0x284b: 0x0100, 0x284c: 0x0100, 0x284d: 0x0100, 0x284e: 0x0100, 0x2851: 0x0100, 0x2852: 0x0100, 0x2853: 0x0100, 0x2854: 0x0100, 0x2855: 0x0100, 0x2856: 0x0100, 0x2860: 0x0100, 0x2861: 0x0100, 0x2862: 0x0100, 0x2863: 0x0100, 0x2864: 0x0100, 0x2865: 0x0100, 0x2866: 0x0100, 0x2868: 0x0100, 0x2869: 0x0100, 0x286a: 0x0100, 0x286b: 0x0100, 0x286c: 0x0100, 0x286d: 0x0100, 0x286e: 0x0100, 0x2870: 0x0040, 0x2871: 0x0040, 0x2872: 0x0040, 0x2873: 0x0040, 0x2874: 0x0040, 0x2875: 0x0040, 0x2876: 0x0040, 0x2877: 0x0040, 0x2878: 0x0040, 0x2879: 0x0040, 0x287a: 0x0040, 0x287b: 0x0040, 0x287c: 0x0040, 0x287d: 0x0040, 0x287e: 0x0040, 0x287f: 0x0040, // Block 0xa2, offset 0x2880 0x2880: 0x0040, 0x2881: 0x0040, 0x2882: 0x0040, 0x2883: 0x0040, 0x2884: 0x0040, 0x2885: 0x0040, 0x2886: 0x0040, 0x2887: 0x0040, 0x2888: 0x0040, 0x2889: 0x0040, 0x288a: 0x0040, 0x288b: 0x0040, 0x288c: 0x0040, 0x288d: 0x0040, 0x288e: 0x0040, 0x288f: 0x0040, 0x2890: 0x0040, 0x2891: 0x0040, 0x2892: 0x0040, 0x2893: 0x0040, 0x2894: 0x0040, 0x2895: 0x0040, 0x2896: 0x0040, 0x2897: 0x0040, 0x2898: 0x0040, 0x2899: 0x0040, 0x289a: 0x0040, 0x289c: 0x0040, 0x289d: 0x0040, 0x289e: 0x0040, 0x289f: 0x0040, 0x28a0: 0x0040, 0x28a1: 0x0040, 0x28a2: 0x0040, 0x28a3: 0x0040, 0x28a4: 0x0040, 0x28a5: 0x0040, 0x28a6: 0x0040, 0x28a7: 0x0040, 0x28a8: 0x0040, 0x28a9: 0x0040, 0x28b0: 0x0040, 0x28b1: 0x0040, 0x28b2: 0x0040, 0x28b3: 0x0040, 0x28b4: 0x0040, 0x28b5: 0x0040, 0x28b6: 0x0040, 0x28b7: 0x0040, 0x28b8: 0x0040, 0x28b9: 0x0040, 0x28ba: 0x0040, 0x28bb: 0x0040, 0x28bc: 0x0040, 0x28bd: 0x0040, 0x28be: 0x0040, 0x28bf: 0x0040, // Block 0xa3, offset 0x28c0 0x28c0: 0x0100, 0x28c1: 0x0100, 0x28c2: 0x0100, 0x28c3: 0x0100, 0x28c4: 0x0100, 0x28c5: 0x0100, 0x28c6: 0x0100, 0x28c7: 0x0100, 0x28c8: 0x0100, 0x28c9: 0x0100, 0x28ca: 0x0100, 0x28cb: 0x0100, 0x28cc: 0x0100, 0x28cd: 0x0100, 0x28ce: 0x0100, 0x28cf: 0x0100, 0x28d0: 0x0100, 0x28d1: 0x0100, 0x28d2: 0x0100, 0x28d3: 0x0100, 0x28d4: 0x0100, 0x28d5: 0x0100, 0x28d6: 0x0100, 0x28d7: 0x0100, 0x28d8: 0x0100, 0x28d9: 0x0100, 0x28da: 0x0100, 0x28db: 0x0100, 0x28dc: 0x0100, 0x28dd: 0x0100, 0x28de: 0x0100, 0x28df: 0x0100, 0x28e0: 0x0100, 0x28e1: 0x0100, 0x28e2: 0x0100, 0x28e3: 0x0008, 0x28e4: 0x0008, 0x28e5: 0x0008, 0x28e6: 0x0008, 0x28e7: 0x0008, 0x28e8: 0x0008, 0x28e9: 0x0008, 0x28ea: 0x0008, 0x28eb: 0x0400, 0x28ec: 0x0008, 0x28ed: 0x0008, 0x28f0: 0x0080, 0x28f1: 0x0080, 0x28f2: 0x0080, 0x28f3: 0x0080, 0x28f4: 0x0080, 0x28f5: 0x0080, 0x28f6: 0x0080, 0x28f7: 0x0080, 0x28f8: 0x0080, 0x28f9: 0x0080, // Block 0xa4, offset 0x2900 0x2900: 0x0100, 0x2901: 0x0100, 0x2902: 0x0100, 0x2903: 0x0100, 0x2904: 0x0100, 0x2905: 0x0100, 0x2906: 0x0100, 0x2907: 0x0100, 0x2908: 0x0100, 0x2909: 0x0100, 0x290a: 0x0100, 0x290b: 0x0100, 0x290c: 0x0100, 0x290d: 0x0100, 0x290e: 0x0100, 0x290f: 0x0100, 0x2910: 0x0100, 0x2911: 0x0100, 0x2912: 0x0100, 0x2913: 0x0100, 0x2914: 0x0100, 0x2915: 0x0100, 0x2916: 0x0100, 0x2917: 0x0100, 0x2918: 0x0100, 0x2919: 0x0100, 0x291a: 0x0100, 0x291b: 0x0100, 0x291c: 0x0100, 0x291d: 0x0100, 0x291e: 0x0100, 0x291f: 0x0100, 0x2920: 0x0100, 0x2921: 0x0100, 0x2922: 0x0100, 0x2923: 0x0100, 0x2930: 0x0100, 0x2931: 0x0100, 0x2932: 0x0100, 0x2933: 0x0100, 0x2934: 0x0100, 0x2935: 0x0100, 0x2936: 0x0100, 0x2937: 0x0100, 0x2938: 0x0100, 0x2939: 0x0100, 0x293a: 0x0100, 0x293b: 0x0100, 0x293c: 0x0100, 0x293d: 0x0100, 0x293e: 0x0100, 0x293f: 0x0100, // Block 0xa5, offset 0x2940 0x2940: 0x0100, 0x2941: 0x0100, 0x2942: 0x0100, 0x2943: 0x0100, 0x2944: 0x0100, 0x2945: 0x0100, 0x2946: 0x0100, 0x294b: 0x0100, 0x294c: 0x0100, 0x294d: 0x0100, 0x294e: 0x0100, 0x294f: 0x0100, 0x2950: 0x0100, 0x2951: 0x0100, 0x2952: 0x0100, 0x2953: 0x0100, 0x2954: 0x0100, 0x2955: 0x0100, 0x2956: 0x0100, 0x2957: 0x0100, 0x2958: 0x0100, 0x2959: 0x0100, 0x295a: 0x0100, 0x295b: 0x0100, 0x295c: 0x0100, 0x295d: 0x0100, 0x295e: 0x0100, 0x295f: 0x0100, 0x2960: 0x0100, 0x2961: 0x0100, 0x2962: 0x0100, 0x2963: 0x0100, 0x2964: 0x0100, 0x2965: 0x0100, 0x2966: 0x0100, 0x2967: 0x0100, 0x2968: 0x0100, 0x2969: 0x0100, 0x296a: 0x0100, 0x296b: 0x0100, 0x296c: 0x0100, 0x296d: 0x0100, 0x296e: 0x0100, 0x296f: 0x0100, 0x2970: 0x0100, 0x2971: 0x0100, 0x2972: 0x0100, 0x2973: 0x0100, 0x2974: 0x0100, 0x2975: 0x0100, 0x2976: 0x0100, 0x2977: 0x0100, 0x2978: 0x0100, 0x2979: 0x0100, 0x297a: 0x0100, 0x297b: 0x0100, // Block 0xa6, offset 0x2980 0x2980: 0x0100, 0x2981: 0x0100, 0x2982: 0x0100, 0x2983: 0x0100, 0x2984: 0x0100, 0x2985: 0x0100, 0x2986: 0x0100, 0x2987: 0x0100, 0x2988: 0x0100, 0x2989: 0x0100, 0x298a: 0x0100, 0x298b: 0x0100, 0x298c: 0x0100, 0x298d: 0x0100, 0x298e: 0x0100, 0x298f: 0x0100, 0x2990: 0x0100, 0x2991: 0x0100, 0x2992: 0x0100, 0x2993: 0x0100, 0x2994: 0x0100, 0x2995: 0x0100, 0x2996: 0x0100, 0x2997: 0x0100, 0x2998: 0x0100, 0x2999: 0x0100, 0x299a: 0x0100, 0x299b: 0x0100, 0x299c: 0x0100, 0x299d: 0x0100, 0x299e: 0x0100, 0x299f: 0x0100, 0x29a0: 0x0100, 0x29a1: 0x0100, 0x29a2: 0x0100, 0x29a3: 0x0100, 0x29a4: 0x0100, 0x29a5: 0x0100, 0x29a6: 0x0100, 0x29a7: 0x0100, 0x29a8: 0x0100, 0x29a9: 0x0100, 0x29aa: 0x0100, 0x29ab: 0x0100, 0x29ac: 0x0100, 0x29ad: 0x0100, 0x29b0: 0x0100, 0x29b1: 0x0100, 0x29b2: 0x0100, 0x29b3: 0x0100, 0x29b4: 0x0100, 0x29b5: 0x0100, 0x29b6: 0x0100, 0x29b7: 0x0100, 0x29b8: 0x0100, 0x29b9: 0x0100, 0x29ba: 0x0100, 0x29bb: 0x0100, 0x29bc: 0x0100, 0x29bd: 0x0100, 0x29be: 0x0100, 0x29bf: 0x0100, // Block 0xa7, offset 0x29c0 0x29c0: 0x0100, 0x29c1: 0x0100, 0x29c2: 0x0100, 0x29c3: 0x0100, 0x29c4: 0x0100, 0x29c5: 0x0100, 0x29c6: 0x0100, 0x29c7: 0x0100, 0x29c8: 0x0100, 0x29c9: 0x0100, 0x29ca: 0x0100, 0x29cb: 0x0100, 0x29cc: 0x0100, 0x29cd: 0x0100, 0x29ce: 0x0100, 0x29cf: 0x0100, 0x29d0: 0x0100, 0x29d1: 0x0100, 0x29d2: 0x0100, 0x29d3: 0x0100, 0x29d4: 0x0100, 0x29d5: 0x0100, 0x29d6: 0x0100, 0x29d7: 0x0100, 0x29d8: 0x0100, 0x29d9: 0x0100, // Block 0xa8, offset 0x2a00 0x2a00: 0x0040, 0x2a01: 0x0040, 0x2a02: 0x0040, 0x2a03: 0x0040, 0x2a04: 0x0040, 0x2a05: 0x0040, 0x2a06: 0x0040, 0x2a13: 0x0040, 0x2a14: 0x0040, 0x2a15: 0x0040, 0x2a16: 0x0040, 0x2a17: 0x0040, 0x2a1d: 0x0100, 0x2a1e: 0x0008, 0x2a1f: 0x0100, 0x2a20: 0x0100, 0x2a21: 0x0100, 0x2a22: 0x0100, 0x2a23: 0x0100, 0x2a24: 0x0100, 0x2a25: 0x0100, 0x2a26: 0x0100, 0x2a27: 0x0100, 0x2a28: 0x0100, 0x2a2a: 0x0100, 0x2a2b: 0x0100, 0x2a2c: 0x0100, 0x2a2d: 0x0100, 0x2a2e: 0x0100, 0x2a2f: 0x0100, 0x2a30: 0x0100, 0x2a31: 0x0100, 0x2a32: 0x0100, 0x2a33: 0x0100, 0x2a34: 0x0100, 0x2a35: 0x0100, 0x2a36: 0x0100, 0x2a38: 0x0100, 0x2a39: 0x0100, 0x2a3a: 0x0100, 0x2a3b: 0x0100, 0x2a3c: 0x0100, 0x2a3e: 0x0100, // Block 0xa9, offset 0x2a40 0x2a40: 0x0100, 0x2a41: 0x0100, 0x2a43: 0x0100, 0x2a44: 0x0100, 0x2a46: 0x0100, 0x2a47: 0x0100, 0x2a48: 0x0100, 0x2a49: 0x0100, 0x2a4a: 0x0100, 0x2a4b: 0x0100, 0x2a4c: 0x0100, 0x2a4d: 0x0100, 0x2a4e: 0x0100, 0x2a4f: 0x0100, 0x2a50: 0x0100, 0x2a51: 0x0100, 0x2a52: 0x0100, 0x2a53: 0x0100, 0x2a54: 0x0100, 0x2a55: 0x0100, 0x2a56: 0x0100, 0x2a57: 0x0100, 0x2a58: 0x0100, 0x2a59: 0x0100, 0x2a5a: 0x0100, 0x2a5b: 0x0100, 0x2a5c: 0x0100, 0x2a5d: 0x0100, 0x2a5e: 0x0100, 0x2a5f: 0x0100, 0x2a60: 0x0100, 0x2a61: 0x0100, 0x2a62: 0x0100, 0x2a63: 0x0100, 0x2a64: 0x0100, 0x2a65: 0x0100, 0x2a66: 0x0100, 0x2a67: 0x0100, 0x2a68: 0x0100, 0x2a69: 0x0100, 0x2a6a: 0x0100, 0x2a6b: 0x0100, 0x2a6c: 0x0100, 0x2a6d: 0x0100, 0x2a6e: 0x0100, 0x2a6f: 0x0100, 0x2a70: 0x0100, 0x2a71: 0x0100, 0x2a72: 0x0100, 0x2a73: 0x0100, 0x2a74: 0x0100, 0x2a75: 0x0100, 0x2a76: 0x0100, 0x2a77: 0x0100, 0x2a78: 0x0100, 0x2a79: 0x0100, 0x2a7a: 0x0100, 0x2a7b: 0x0100, 0x2a7c: 0x0100, 0x2a7d: 0x0100, 0x2a7e: 0x0100, 0x2a7f: 0x0100, // Block 0xaa, offset 0x2a80 0x2a80: 0x0100, 0x2a81: 0x0100, 0x2a82: 0x0100, 0x2a83: 0x0100, 0x2a84: 0x0100, 0x2a85: 0x0100, 0x2a86: 0x0100, 0x2a87: 0x0100, 0x2a88: 0x0100, 0x2a89: 0x0100, 0x2a8a: 0x0100, 0x2a8b: 0x0100, 0x2a8c: 0x0100, 0x2a8d: 0x0100, 0x2a8e: 0x0100, 0x2a8f: 0x0100, 0x2a90: 0x0100, 0x2a91: 0x0100, 0x2a92: 0x0100, 0x2a93: 0x0100, 0x2a94: 0x0100, 0x2a95: 0x0100, 0x2a96: 0x0100, 0x2a97: 0x0100, 0x2a98: 0x0100, 0x2a99: 0x0100, 0x2a9a: 0x0100, 0x2a9b: 0x0100, 0x2a9c: 0x0100, 0x2a9d: 0x0100, 0x2a9e: 0x0100, 0x2a9f: 0x0100, 0x2aa0: 0x0100, 0x2aa1: 0x0100, 0x2aa2: 0x0100, 0x2aa3: 0x0100, 0x2aa4: 0x0100, 0x2aa5: 0x0100, 0x2aa6: 0x0100, 0x2aa7: 0x0100, 0x2aa8: 0x0100, 0x2aa9: 0x0100, 0x2aaa: 0x0100, 0x2aab: 0x0100, 0x2aac: 0x0100, 0x2aad: 0x0100, 0x2aae: 0x0100, 0x2aaf: 0x0100, 0x2ab0: 0x0100, 0x2ab1: 0x0100, // Block 0xab, offset 0x2ac0 0x2ad3: 0x0100, 0x2ad4: 0x0100, 0x2ad5: 0x0100, 0x2ad6: 0x0100, 0x2ad7: 0x0100, 0x2ad8: 0x0100, 0x2ad9: 0x0100, 0x2ada: 0x0100, 0x2adb: 0x0100, 0x2adc: 0x0100, 0x2add: 0x0100, 0x2ade: 0x0100, 0x2adf: 0x0100, 0x2ae0: 0x0100, 0x2ae1: 0x0100, 0x2ae2: 0x0100, 0x2ae3: 0x0100, 0x2ae4: 0x0100, 0x2ae5: 0x0100, 0x2ae6: 0x0100, 0x2ae7: 0x0100, 0x2ae8: 0x0100, 0x2ae9: 0x0100, 0x2aea: 0x0100, 0x2aeb: 0x0100, 0x2aec: 0x0100, 0x2aed: 0x0100, 0x2aee: 0x0100, 0x2aef: 0x0100, 0x2af0: 0x0100, 0x2af1: 0x0100, 0x2af2: 0x0100, 0x2af3: 0x0100, 0x2af4: 0x0100, 0x2af5: 0x0100, 0x2af6: 0x0100, 0x2af7: 0x0100, 0x2af8: 0x0100, 0x2af9: 0x0100, 0x2afa: 0x0100, 0x2afb: 0x0100, 0x2afc: 0x0100, 0x2afd: 0x0100, 0x2afe: 0x0100, 0x2aff: 0x0100, // Block 0xac, offset 0x2b00 0x2b00: 0x0100, 0x2b01: 0x0100, 0x2b02: 0x0100, 0x2b03: 0x0100, 0x2b04: 0x0100, 0x2b05: 0x0100, 0x2b06: 0x0100, 0x2b07: 0x0100, 0x2b08: 0x0100, 0x2b09: 0x0100, 0x2b0a: 0x0100, 0x2b0b: 0x0100, 0x2b0c: 0x0100, 0x2b0d: 0x0100, 0x2b0e: 0x0100, 0x2b0f: 0x0100, 0x2b10: 0x0100, 0x2b11: 0x0100, 0x2b12: 0x0100, 0x2b13: 0x0100, 0x2b14: 0x0100, 0x2b15: 0x0100, 0x2b16: 0x0100, 0x2b17: 0x0100, 0x2b18: 0x0100, 0x2b19: 0x0100, 0x2b1a: 0x0100, 0x2b1b: 0x0100, 0x2b1c: 0x0100, 0x2b1d: 0x0100, 0x2b1e: 0x0100, 0x2b1f: 0x0100, 0x2b20: 0x0100, 0x2b21: 0x0100, 0x2b22: 0x0100, 0x2b23: 0x0100, 0x2b24: 0x0100, 0x2b25: 0x0100, 0x2b26: 0x0100, 0x2b27: 0x0100, 0x2b28: 0x0100, 0x2b29: 0x0100, 0x2b2a: 0x0100, 0x2b2b: 0x0100, 0x2b2c: 0x0100, 0x2b2d: 0x0100, 0x2b2e: 0x0100, 0x2b2f: 0x0100, 0x2b30: 0x0100, 0x2b31: 0x0100, 0x2b32: 0x0100, 0x2b33: 0x0100, 0x2b34: 0x0100, 0x2b35: 0x0100, 0x2b36: 0x0100, 0x2b37: 0x0100, 0x2b38: 0x0100, 0x2b39: 0x0100, 0x2b3a: 0x0100, 0x2b3b: 0x0100, 0x2b3c: 0x0100, 0x2b3d: 0x0100, 0x2b3e: 0x0004, 0x2b3f: 0x0004, // Block 0xad, offset 0x2b40 0x2b50: 0x0100, 0x2b51: 0x0100, 0x2b52: 0x0100, 0x2b53: 0x0100, 0x2b54: 0x0100, 0x2b55: 0x0100, 0x2b56: 0x0100, 0x2b57: 0x0100, 0x2b58: 0x0100, 0x2b59: 0x0100, 0x2b5a: 0x0100, 0x2b5b: 0x0100, 0x2b5c: 0x0100, 0x2b5d: 0x0100, 0x2b5e: 0x0100, 0x2b5f: 0x0100, 0x2b60: 0x0100, 0x2b61: 0x0100, 0x2b62: 0x0100, 0x2b63: 0x0100, 0x2b64: 0x0100, 0x2b65: 0x0100, 0x2b66: 0x0100, 0x2b67: 0x0100, 0x2b68: 0x0100, 0x2b69: 0x0100, 0x2b6a: 0x0100, 0x2b6b: 0x0100, 0x2b6c: 0x0100, 0x2b6d: 0x0100, 0x2b6e: 0x0100, 0x2b6f: 0x0100, 0x2b70: 0x0100, 0x2b71: 0x0100, 0x2b72: 0x0100, 0x2b73: 0x0100, 0x2b74: 0x0100, 0x2b75: 0x0100, 0x2b76: 0x0100, 0x2b77: 0x0100, 0x2b78: 0x0100, 0x2b79: 0x0100, 0x2b7a: 0x0100, 0x2b7b: 0x0100, 0x2b7c: 0x0100, 0x2b7d: 0x0100, 0x2b7e: 0x0100, 0x2b7f: 0x0100, // Block 0xae, offset 0x2b80 0x2b80: 0x0100, 0x2b81: 0x0100, 0x2b82: 0x0100, 0x2b83: 0x0100, 0x2b84: 0x0100, 0x2b85: 0x0100, 0x2b86: 0x0100, 0x2b87: 0x0100, 0x2b88: 0x0100, 0x2b89: 0x0100, 0x2b8a: 0x0100, 0x2b8b: 0x0100, 0x2b8c: 0x0100, 0x2b8d: 0x0100, 0x2b8e: 0x0100, 0x2b8f: 0x0100, 0x2b92: 0x0100, 0x2b93: 0x0100, 0x2b94: 0x0100, 0x2b95: 0x0100, 0x2b96: 0x0100, 0x2b97: 0x0100, 0x2b98: 0x0100, 0x2b99: 0x0100, 0x2b9a: 0x0100, 0x2b9b: 0x0100, 0x2b9c: 0x0100, 0x2b9d: 0x0100, 0x2b9e: 0x0100, 0x2b9f: 0x0100, 0x2ba0: 0x0100, 0x2ba1: 0x0100, 0x2ba2: 0x0100, 0x2ba3: 0x0100, 0x2ba4: 0x0100, 0x2ba5: 0x0100, 0x2ba6: 0x0100, 0x2ba7: 0x0100, 0x2ba8: 0x0100, 0x2ba9: 0x0100, 0x2baa: 0x0100, 0x2bab: 0x0100, 0x2bac: 0x0100, 0x2bad: 0x0100, 0x2bae: 0x0100, 0x2baf: 0x0100, 0x2bb0: 0x0100, 0x2bb1: 0x0100, 0x2bb2: 0x0100, 0x2bb3: 0x0100, 0x2bb4: 0x0100, 0x2bb5: 0x0100, 0x2bb6: 0x0100, 0x2bb7: 0x0100, 0x2bb8: 0x0100, 0x2bb9: 0x0100, 0x2bba: 0x0100, 0x2bbb: 0x0100, 0x2bbc: 0x0100, 0x2bbd: 0x0100, 0x2bbe: 0x0100, 0x2bbf: 0x0100, // Block 0xaf, offset 0x2bc0 0x2bc0: 0x0100, 0x2bc1: 0x0100, 0x2bc2: 0x0100, 0x2bc3: 0x0100, 0x2bc4: 0x0100, 0x2bc5: 0x0100, 0x2bc6: 0x0100, 0x2bc7: 0x0100, 0x2bf0: 0x0100, 0x2bf1: 0x0100, 0x2bf2: 0x0100, 0x2bf3: 0x0100, 0x2bf4: 0x0100, 0x2bf5: 0x0100, 0x2bf6: 0x0100, 0x2bf7: 0x0100, 0x2bf8: 0x0100, 0x2bf9: 0x0100, 0x2bfa: 0x0100, 0x2bfb: 0x0100, // Block 0xb0, offset 0x2c00 0x2c00: 0x0008, 0x2c01: 0x0008, 0x2c02: 0x0008, 0x2c03: 0x0008, 0x2c04: 0x0008, 0x2c05: 0x0008, 0x2c06: 0x0008, 0x2c07: 0x0008, 0x2c08: 0x0008, 0x2c09: 0x0008, 0x2c0a: 0x0008, 0x2c0b: 0x0008, 0x2c0c: 0x0008, 0x2c0d: 0x0008, 0x2c0e: 0x0008, 0x2c0f: 0x0008, 0x2c10: 0x0200, 0x2c11: 0x0200, 0x2c12: 0x0400, 0x2c13: 0x0200, 0x2c14: 0x0200, 0x2c15: 0x0400, 0x2c16: 0x0400, 0x2c17: 0x0004, 0x2c18: 0x0004, 0x2c20: 0x0008, 0x2c21: 0x0008, 0x2c22: 0x0008, 0x2c23: 0x0008, 0x2c24: 0x0008, 0x2c25: 0x0008, 0x2c26: 0x0008, 0x2c27: 0x0008, 0x2c28: 0x0008, 0x2c29: 0x0008, 0x2c2a: 0x0008, 0x2c2b: 0x0008, 0x2c2c: 0x0008, 0x2c2d: 0x0008, 0x2c2e: 0x0008, 0x2c2f: 0x0008, 0x2c31: 0x0200, 0x2c32: 0x0200, 0x2c35: 0x0004, 0x2c36: 0x0004, 0x2c37: 0x0004, 0x2c38: 0x0004, 0x2c39: 0x0004, 0x2c3a: 0x0004, 0x2c3b: 0x0004, 0x2c3c: 0x0004, 0x2c3d: 0x0004, 0x2c3e: 0x0004, 0x2c3f: 0x0004, // Block 0xb1, offset 0x2c40 0x2c40: 0x0004, 0x2c41: 0x0004, 0x2c42: 0x0004, 0x2c43: 0x0004, 0x2c44: 0x0004, 0x2c47: 0x0004, 0x2c48: 0x0004, 0x2c50: 0x0200, 0x2c51: 0x0200, 0x2c52: 0x0001, 0x2c54: 0x0200, 0x2c55: 0x0200, 0x2c56: 0x0400, 0x2c57: 0x0400, 0x2c58: 0x0200, 0x2c59: 0x0004, 0x2c5a: 0x0004, 0x2c5b: 0x0004, 0x2c5c: 0x0004, 0x2c5d: 0x0004, 0x2c5e: 0x0004, 0x2c63: 0x0200, 0x2c70: 0x0100, 0x2c71: 0x0100, 0x2c72: 0x0100, 0x2c73: 0x0100, 0x2c74: 0x0100, 0x2c76: 0x0100, 0x2c77: 0x0100, 0x2c78: 0x0100, 0x2c79: 0x0100, 0x2c7a: 0x0100, 0x2c7b: 0x0100, 0x2c7c: 0x0100, 0x2c7d: 0x0100, 0x2c7e: 0x0100, 0x2c7f: 0x0100, // Block 0xb2, offset 0x2c80 0x2c80: 0x0100, 0x2c81: 0x0100, 0x2c82: 0x0100, 0x2c83: 0x0100, 0x2c84: 0x0100, 0x2c85: 0x0100, 0x2c86: 0x0100, 0x2c87: 0x0100, 0x2c88: 0x0100, 0x2c89: 0x0100, 0x2c8a: 0x0100, 0x2c8b: 0x0100, 0x2c8c: 0x0100, 0x2c8d: 0x0100, 0x2c8e: 0x0100, 0x2c8f: 0x0100, 0x2c90: 0x0100, 0x2c91: 0x0100, 0x2c92: 0x0100, 0x2c93: 0x0100, 0x2c94: 0x0100, 0x2c95: 0x0100, 0x2c96: 0x0100, 0x2c97: 0x0100, 0x2c98: 0x0100, 0x2c99: 0x0100, 0x2c9a: 0x0100, 0x2c9b: 0x0100, 0x2c9c: 0x0100, 0x2c9d: 0x0100, 0x2c9e: 0x0100, 0x2c9f: 0x0100, 0x2ca0: 0x0100, 0x2ca1: 0x0100, 0x2ca2: 0x0100, 0x2ca3: 0x0100, 0x2ca4: 0x0100, 0x2ca5: 0x0100, 0x2ca6: 0x0100, 0x2ca7: 0x0100, 0x2ca8: 0x0100, 0x2ca9: 0x0100, 0x2caa: 0x0100, 0x2cab: 0x0100, 0x2cac: 0x0100, 0x2cad: 0x0100, 0x2cae: 0x0100, 0x2caf: 0x0100, 0x2cb0: 0x0100, 0x2cb1: 0x0100, 0x2cb2: 0x0100, 0x2cb3: 0x0100, 0x2cb4: 0x0100, 0x2cb5: 0x0100, 0x2cb6: 0x0100, 0x2cb7: 0x0100, 0x2cb8: 0x0100, 0x2cb9: 0x0100, 0x2cba: 0x0100, 0x2cbb: 0x0100, 0x2cbc: 0x0100, 0x2cbf: 0x0010, // Block 0xb3, offset 0x2cc0 0x2cc1: 0x0400, 0x2cc8: 0x0004, 0x2cc9: 0x0004, 0x2ccc: 0x0200, 0x2ccd: 0x0200, 0x2cce: 0x0001, 0x2cd0: 0x0080, 0x2cd1: 0x0080, 0x2cd2: 0x0080, 0x2cd3: 0x0080, 0x2cd4: 0x0080, 0x2cd5: 0x0080, 0x2cd6: 0x0080, 0x2cd7: 0x0080, 0x2cd8: 0x0080, 0x2cd9: 0x0080, 0x2cda: 0x0200, 0x2cdb: 0x0200, 0x2cdf: 0x0400, 0x2ce1: 0x2000, 0x2ce2: 0x2000, 0x2ce3: 0x2000, 0x2ce4: 0x2000, 0x2ce5: 0x2000, 0x2ce6: 0x2000, 0x2ce7: 0x2000, 0x2ce8: 0x2000, 0x2ce9: 0x2000, 0x2cea: 0x2000, 0x2ceb: 0x2000, 0x2cec: 0x2000, 0x2ced: 0x2000, 0x2cee: 0x2000, 0x2cef: 0x2000, 0x2cf0: 0x2000, 0x2cf1: 0x2000, 0x2cf2: 0x2000, 0x2cf3: 0x2000, 0x2cf4: 0x2000, 0x2cf5: 0x2000, 0x2cf6: 0x2000, 0x2cf7: 0x2000, 0x2cf8: 0x2000, 0x2cf9: 0x2000, 0x2cfa: 0x2000, 0x2cfb: 0x0004, 0x2cfd: 0x0004, // Block 0xb4, offset 0x2d00 0x2d01: 0x0040, 0x2d02: 0x0040, 0x2d03: 0x0040, 0x2d04: 0x0040, 0x2d05: 0x0040, 0x2d06: 0x0040, 0x2d07: 0x0040, 0x2d08: 0x0040, 0x2d09: 0x0040, 0x2d0a: 0x0040, 0x2d0b: 0x0040, 0x2d0c: 0x0040, 0x2d0d: 0x0040, 0x2d0e: 0x0040, 0x2d0f: 0x0040, 0x2d10: 0x0040, 0x2d11: 0x0040, 0x2d12: 0x0040, 0x2d13: 0x0040, 0x2d14: 0x0040, 0x2d15: 0x0040, 0x2d16: 0x0040, 0x2d17: 0x0040, 0x2d18: 0x0040, 0x2d19: 0x0040, 0x2d1a: 0x0040, 0x2d1b: 0x0004, 0x2d1d: 0x0004, 0x2d1f: 0x0004, 0x2d20: 0x0004, 0x2d21: 0x0400, 0x2d22: 0x0004, 0x2d23: 0x0004, 0x2d24: 0x0200, 0x2d26: 0x0100, 0x2d27: 0x0100, 0x2d28: 0x0100, 0x2d29: 0x0100, 0x2d2a: 0x0100, 0x2d2b: 0x0100, 0x2d2c: 0x0100, 0x2d2d: 0x0100, 0x2d2e: 0x0100, 0x2d2f: 0x0100, 0x2d30: 0x0100, 0x2d31: 0x0100, 0x2d32: 0x0100, 0x2d33: 0x0100, 0x2d34: 0x0100, 0x2d35: 0x0100, 0x2d36: 0x0100, 0x2d37: 0x0100, 0x2d38: 0x0100, 0x2d39: 0x0100, 0x2d3a: 0x0100, 0x2d3b: 0x0100, 0x2d3c: 0x0100, 0x2d3d: 0x0100, 0x2d3e: 0x0100, 0x2d3f: 0x0100, // Block 0xb5, offset 0x2d40 0x2d40: 0x0100, 0x2d41: 0x0100, 0x2d42: 0x0100, 0x2d43: 0x0100, 0x2d44: 0x0100, 0x2d45: 0x0100, 0x2d46: 0x0100, 0x2d47: 0x0100, 0x2d48: 0x0100, 0x2d49: 0x0100, 0x2d4a: 0x0100, 0x2d4b: 0x0100, 0x2d4c: 0x0100, 0x2d4d: 0x0100, 0x2d4e: 0x0100, 0x2d4f: 0x0100, 0x2d50: 0x0100, 0x2d51: 0x0100, 0x2d52: 0x0100, 0x2d53: 0x0100, 0x2d54: 0x0100, 0x2d55: 0x0100, 0x2d56: 0x0100, 0x2d57: 0x0100, 0x2d58: 0x0100, 0x2d59: 0x0100, 0x2d5a: 0x0100, 0x2d5b: 0x0100, 0x2d5c: 0x0100, 0x2d5d: 0x0100, 0x2d5e: 0x0008, 0x2d5f: 0x0008, 0x2d60: 0x0100, 0x2d61: 0x0100, 0x2d62: 0x0100, 0x2d63: 0x0100, 0x2d64: 0x0100, 0x2d65: 0x0100, 0x2d66: 0x0100, 0x2d67: 0x0100, 0x2d68: 0x0100, 0x2d69: 0x0100, 0x2d6a: 0x0100, 0x2d6b: 0x0100, 0x2d6c: 0x0100, 0x2d6d: 0x0100, 0x2d6e: 0x0100, 0x2d6f: 0x0100, 0x2d70: 0x0100, 0x2d71: 0x0100, 0x2d72: 0x0100, 0x2d73: 0x0100, 0x2d74: 0x0100, 0x2d75: 0x0100, 0x2d76: 0x0100, 0x2d77: 0x0100, 0x2d78: 0x0100, 0x2d79: 0x0100, 0x2d7a: 0x0100, 0x2d7b: 0x0100, 0x2d7c: 0x0100, 0x2d7d: 0x0100, 0x2d7e: 0x0100, // Block 0xb6, offset 0x2d80 0x2d82: 0x0100, 0x2d83: 0x0100, 0x2d84: 0x0100, 0x2d85: 0x0100, 0x2d86: 0x0100, 0x2d87: 0x0100, 0x2d8a: 0x0100, 0x2d8b: 0x0100, 0x2d8c: 0x0100, 0x2d8d: 0x0100, 0x2d8e: 0x0100, 0x2d8f: 0x0100, 0x2d92: 0x0100, 0x2d93: 0x0100, 0x2d94: 0x0100, 0x2d95: 0x0100, 0x2d96: 0x0100, 0x2d97: 0x0100, 0x2d9a: 0x0100, 0x2d9b: 0x0100, 0x2d9c: 0x0100, 0x2db9: 0x0010, 0x2dba: 0x0010, 0x2dbb: 0x0010, // Block 0xb7, offset 0x2dc0 0x2dc0: 0x0100, 0x2dc1: 0x0100, 0x2dc2: 0x0100, 0x2dc3: 0x0100, 0x2dc4: 0x0100, 0x2dc5: 0x0100, 0x2dc6: 0x0100, 0x2dc7: 0x0100, 0x2dc8: 0x0100, 0x2dc9: 0x0100, 0x2dca: 0x0100, 0x2dcb: 0x0100, 0x2dcd: 0x0100, 0x2dce: 0x0100, 0x2dcf: 0x0100, 0x2dd0: 0x0100, 0x2dd1: 0x0100, 0x2dd2: 0x0100, 0x2dd3: 0x0100, 0x2dd4: 0x0100, 0x2dd5: 0x0100, 0x2dd6: 0x0100, 0x2dd7: 0x0100, 0x2dd8: 0x0100, 0x2dd9: 0x0100, 0x2dda: 0x0100, 0x2ddb: 0x0100, 0x2ddc: 0x0100, 0x2ddd: 0x0100, 0x2dde: 0x0100, 0x2ddf: 0x0100, 0x2de0: 0x0100, 0x2de1: 0x0100, 0x2de2: 0x0100, 0x2de3: 0x0100, 0x2de4: 0x0100, 0x2de5: 0x0100, 0x2de6: 0x0100, 0x2de8: 0x0100, 0x2de9: 0x0100, 0x2dea: 0x0100, 0x2deb: 0x0100, 0x2dec: 0x0100, 0x2ded: 0x0100, 0x2dee: 0x0100, 0x2def: 0x0100, 0x2df0: 0x0100, 0x2df1: 0x0100, 0x2df2: 0x0100, 0x2df3: 0x0100, 0x2df4: 0x0100, 0x2df5: 0x0100, 0x2df6: 0x0100, 0x2df7: 0x0100, 0x2df8: 0x0100, 0x2df9: 0x0100, 0x2dfa: 0x0100, 0x2dfc: 0x0100, 0x2dfd: 0x0100, 0x2dff: 0x0100, // Block 0xb8, offset 0x2e00 0x2e00: 0x0100, 0x2e01: 0x0100, 0x2e02: 0x0100, 0x2e03: 0x0100, 0x2e04: 0x0100, 0x2e05: 0x0100, 0x2e06: 0x0100, 0x2e07: 0x0100, 0x2e08: 0x0100, 0x2e09: 0x0100, 0x2e0a: 0x0100, 0x2e0b: 0x0100, 0x2e0c: 0x0100, 0x2e0d: 0x0100, 0x2e10: 0x0100, 0x2e11: 0x0100, 0x2e12: 0x0100, 0x2e13: 0x0100, 0x2e14: 0x0100, 0x2e15: 0x0100, 0x2e16: 0x0100, 0x2e17: 0x0100, 0x2e18: 0x0100, 0x2e19: 0x0100, 0x2e1a: 0x0100, 0x2e1b: 0x0100, 0x2e1c: 0x0100, 0x2e1d: 0x0100, // Block 0xb9, offset 0x2e40 0x2e40: 0x0100, 0x2e41: 0x0100, 0x2e42: 0x0100, 0x2e43: 0x0100, 0x2e44: 0x0100, 0x2e45: 0x0100, 0x2e46: 0x0100, 0x2e47: 0x0100, 0x2e48: 0x0100, 0x2e49: 0x0100, 0x2e4a: 0x0100, 0x2e4b: 0x0100, 0x2e4c: 0x0100, 0x2e4d: 0x0100, 0x2e4e: 0x0100, 0x2e4f: 0x0100, 0x2e50: 0x0100, 0x2e51: 0x0100, 0x2e52: 0x0100, 0x2e53: 0x0100, 0x2e54: 0x0100, 0x2e55: 0x0100, 0x2e56: 0x0100, 0x2e57: 0x0100, 0x2e58: 0x0100, 0x2e59: 0x0100, 0x2e5a: 0x0100, 0x2e5b: 0x0100, 0x2e5c: 0x0100, 0x2e5d: 0x0100, 0x2e5e: 0x0100, 0x2e5f: 0x0100, 0x2e60: 0x0100, 0x2e61: 0x0100, 0x2e62: 0x0100, 0x2e63: 0x0100, 0x2e64: 0x0100, 0x2e65: 0x0100, 0x2e66: 0x0100, 0x2e67: 0x0100, 0x2e68: 0x0100, 0x2e69: 0x0100, 0x2e6a: 0x0100, 0x2e6b: 0x0100, 0x2e6c: 0x0100, 0x2e6d: 0x0100, 0x2e6e: 0x0100, 0x2e6f: 0x0100, 0x2e70: 0x0100, 0x2e71: 0x0100, 0x2e72: 0x0100, 0x2e73: 0x0100, 0x2e74: 0x0100, 0x2e75: 0x0100, 0x2e76: 0x0100, 0x2e77: 0x0100, 0x2e78: 0x0100, 0x2e79: 0x0100, 0x2e7a: 0x0100, // Block 0xba, offset 0x2e80 0x2e80: 0x0100, 0x2e81: 0x0100, 0x2e82: 0x0100, 0x2e83: 0x0100, 0x2e84: 0x0100, 0x2e85: 0x0100, 0x2e86: 0x0100, 0x2e87: 0x0100, 0x2e88: 0x0100, 0x2e89: 0x0100, 0x2e8a: 0x0100, 0x2e8b: 0x0100, 0x2e8c: 0x0100, 0x2e8d: 0x0100, 0x2e8e: 0x0100, 0x2e8f: 0x0100, 0x2e90: 0x0100, 0x2e91: 0x0100, 0x2e92: 0x0100, 0x2e93: 0x0100, 0x2e94: 0x0100, 0x2e95: 0x0100, 0x2e96: 0x0100, 0x2e97: 0x0100, 0x2e98: 0x0100, 0x2e99: 0x0100, 0x2e9a: 0x0100, 0x2e9b: 0x0100, 0x2e9c: 0x0100, 0x2e9d: 0x0100, 0x2e9e: 0x0100, 0x2e9f: 0x0100, 0x2ea0: 0x0100, 0x2ea1: 0x0100, 0x2ea2: 0x0100, 0x2ea3: 0x0100, 0x2ea4: 0x0100, 0x2ea5: 0x0100, 0x2ea6: 0x0100, 0x2ea7: 0x0100, 0x2ea8: 0x0100, 0x2ea9: 0x0100, 0x2eaa: 0x0100, 0x2eab: 0x0100, 0x2eac: 0x0100, 0x2ead: 0x0100, 0x2eae: 0x0100, 0x2eaf: 0x0100, 0x2eb0: 0x0100, 0x2eb1: 0x0100, 0x2eb2: 0x0100, 0x2eb3: 0x0100, 0x2eb4: 0x0100, // Block 0xbb, offset 0x2ec0 0x2efd: 0x0008, // Block 0xbc, offset 0x2f00 0x2f00: 0x0100, 0x2f01: 0x0100, 0x2f02: 0x0100, 0x2f03: 0x0100, 0x2f04: 0x0100, 0x2f05: 0x0100, 0x2f06: 0x0100, 0x2f07: 0x0100, 0x2f08: 0x0100, 0x2f09: 0x0100, 0x2f0a: 0x0100, 0x2f0b: 0x0100, 0x2f0c: 0x0100, 0x2f0d: 0x0100, 0x2f0e: 0x0100, 0x2f0f: 0x0100, 0x2f10: 0x0100, 0x2f11: 0x0100, 0x2f12: 0x0100, 0x2f13: 0x0100, 0x2f14: 0x0100, 0x2f15: 0x0100, 0x2f16: 0x0100, 0x2f17: 0x0100, 0x2f18: 0x0100, 0x2f19: 0x0100, 0x2f1a: 0x0100, 0x2f1b: 0x0100, 0x2f1c: 0x0100, 0x2f20: 0x0100, 0x2f21: 0x0100, 0x2f22: 0x0100, 0x2f23: 0x0100, 0x2f24: 0x0100, 0x2f25: 0x0100, 0x2f26: 0x0100, 0x2f27: 0x0100, 0x2f28: 0x0100, 0x2f29: 0x0100, 0x2f2a: 0x0100, 0x2f2b: 0x0100, 0x2f2c: 0x0100, 0x2f2d: 0x0100, 0x2f2e: 0x0100, 0x2f2f: 0x0100, 0x2f30: 0x0100, 0x2f31: 0x0100, 0x2f32: 0x0100, 0x2f33: 0x0100, 0x2f34: 0x0100, 0x2f35: 0x0100, 0x2f36: 0x0100, 0x2f37: 0x0100, 0x2f38: 0x0100, 0x2f39: 0x0100, 0x2f3a: 0x0100, 0x2f3b: 0x0100, 0x2f3c: 0x0100, 0x2f3d: 0x0100, 0x2f3e: 0x0100, 0x2f3f: 0x0100, // Block 0xbd, offset 0x2f40 0x2f40: 0x0100, 0x2f41: 0x0100, 0x2f42: 0x0100, 0x2f43: 0x0100, 0x2f44: 0x0100, 0x2f45: 0x0100, 0x2f46: 0x0100, 0x2f47: 0x0100, 0x2f48: 0x0100, 0x2f49: 0x0100, 0x2f4a: 0x0100, 0x2f4b: 0x0100, 0x2f4c: 0x0100, 0x2f4d: 0x0100, 0x2f4e: 0x0100, 0x2f4f: 0x0100, 0x2f50: 0x0100, 0x2f60: 0x0008, // Block 0xbe, offset 0x2f80 0x2f80: 0x0100, 0x2f81: 0x0100, 0x2f82: 0x0100, 0x2f83: 0x0100, 0x2f84: 0x0100, 0x2f85: 0x0100, 0x2f86: 0x0100, 0x2f87: 0x0100, 0x2f88: 0x0100, 0x2f89: 0x0100, 0x2f8a: 0x0100, 0x2f8b: 0x0100, 0x2f8c: 0x0100, 0x2f8d: 0x0100, 0x2f8e: 0x0100, 0x2f8f: 0x0100, 0x2f90: 0x0100, 0x2f91: 0x0100, 0x2f92: 0x0100, 0x2f93: 0x0100, 0x2f94: 0x0100, 0x2f95: 0x0100, 0x2f96: 0x0100, 0x2f97: 0x0100, 0x2f98: 0x0100, 0x2f99: 0x0100, 0x2f9a: 0x0100, 0x2f9b: 0x0100, 0x2f9c: 0x0100, 0x2f9d: 0x0100, 0x2f9e: 0x0100, 0x2f9f: 0x0100, 0x2fad: 0x0100, 0x2fae: 0x0100, 0x2faf: 0x0100, 0x2fb0: 0x0100, 0x2fb1: 0x0100, 0x2fb2: 0x0100, 0x2fb3: 0x0100, 0x2fb4: 0x0100, 0x2fb5: 0x0100, 0x2fb6: 0x0100, 0x2fb7: 0x0100, 0x2fb8: 0x0100, 0x2fb9: 0x0100, 0x2fba: 0x0100, 0x2fbb: 0x0100, 0x2fbc: 0x0100, 0x2fbd: 0x0100, 0x2fbe: 0x0100, 0x2fbf: 0x0100, // Block 0xbf, offset 0x2fc0 0x2fc0: 0x0100, 0x2fc1: 0x0100, 0x2fc2: 0x0100, 0x2fc3: 0x0100, 0x2fc4: 0x0100, 0x2fc5: 0x0100, 0x2fc6: 0x0100, 0x2fc7: 0x0100, 0x2fc8: 0x0100, 0x2fc9: 0x0100, 0x2fca: 0x0100, 0x2fd0: 0x0100, 0x2fd1: 0x0100, 0x2fd2: 0x0100, 0x2fd3: 0x0100, 0x2fd4: 0x0100, 0x2fd5: 0x0100, 0x2fd6: 0x0100, 0x2fd7: 0x0100, 0x2fd8: 0x0100, 0x2fd9: 0x0100, 0x2fda: 0x0100, 0x2fdb: 0x0100, 0x2fdc: 0x0100, 0x2fdd: 0x0100, 0x2fde: 0x0100, 0x2fdf: 0x0100, 0x2fe0: 0x0100, 0x2fe1: 0x0100, 0x2fe2: 0x0100, 0x2fe3: 0x0100, 0x2fe4: 0x0100, 0x2fe5: 0x0100, 0x2fe6: 0x0100, 0x2fe7: 0x0100, 0x2fe8: 0x0100, 0x2fe9: 0x0100, 0x2fea: 0x0100, 0x2feb: 0x0100, 0x2fec: 0x0100, 0x2fed: 0x0100, 0x2fee: 0x0100, 0x2fef: 0x0100, 0x2ff0: 0x0100, 0x2ff1: 0x0100, 0x2ff2: 0x0100, 0x2ff3: 0x0100, 0x2ff4: 0x0100, 0x2ff5: 0x0100, 0x2ff6: 0x0008, 0x2ff7: 0x0008, 0x2ff8: 0x0008, 0x2ff9: 0x0008, 0x2ffa: 0x0008, // Block 0xc0, offset 0x3000 0x3000: 0x0100, 0x3001: 0x0100, 0x3002: 0x0100, 0x3003: 0x0100, 0x3004: 0x0100, 0x3005: 0x0100, 0x3006: 0x0100, 0x3007: 0x0100, 0x3008: 0x0100, 0x3009: 0x0100, 0x300a: 0x0100, 0x300b: 0x0100, 0x300c: 0x0100, 0x300d: 0x0100, 0x300e: 0x0100, 0x300f: 0x0100, 0x3010: 0x0100, 0x3011: 0x0100, 0x3012: 0x0100, 0x3013: 0x0100, 0x3014: 0x0100, 0x3015: 0x0100, 0x3016: 0x0100, 0x3017: 0x0100, 0x3018: 0x0100, 0x3019: 0x0100, 0x301a: 0x0100, 0x301b: 0x0100, 0x301c: 0x0100, 0x301d: 0x0100, 0x3020: 0x0100, 0x3021: 0x0100, 0x3022: 0x0100, 0x3023: 0x0100, 0x3024: 0x0100, 0x3025: 0x0100, 0x3026: 0x0100, 0x3027: 0x0100, 0x3028: 0x0100, 0x3029: 0x0100, 0x302a: 0x0100, 0x302b: 0x0100, 0x302c: 0x0100, 0x302d: 0x0100, 0x302e: 0x0100, 0x302f: 0x0100, 0x3030: 0x0100, 0x3031: 0x0100, 0x3032: 0x0100, 0x3033: 0x0100, 0x3034: 0x0100, 0x3035: 0x0100, 0x3036: 0x0100, 0x3037: 0x0100, 0x3038: 0x0100, 0x3039: 0x0100, 0x303a: 0x0100, 0x303b: 0x0100, 0x303c: 0x0100, 0x303d: 0x0100, 0x303e: 0x0100, 0x303f: 0x0100, // Block 0xc1, offset 0x3040 0x3040: 0x0100, 0x3041: 0x0100, 0x3042: 0x0100, 0x3043: 0x0100, 0x3048: 0x0100, 0x3049: 0x0100, 0x304a: 0x0100, 0x304b: 0x0100, 0x304c: 0x0100, 0x304d: 0x0100, 0x304e: 0x0100, 0x304f: 0x0100, 0x3051: 0x0100, 0x3052: 0x0100, 0x3053: 0x0100, 0x3054: 0x0100, 0x3055: 0x0100, // Block 0xc2, offset 0x3080 0x3080: 0x2000, 0x3081: 0x2000, 0x3082: 0x2000, 0x3083: 0x2000, 0x3084: 0x2000, 0x3085: 0x2000, 0x3086: 0x2000, 0x3087: 0x2000, 0x3088: 0x2000, 0x3089: 0x2000, 0x308a: 0x2000, 0x308b: 0x2000, 0x308c: 0x2000, 0x308d: 0x2000, 0x308e: 0x2000, 0x308f: 0x2000, 0x3090: 0x2000, 0x3091: 0x2000, 0x3092: 0x2000, 0x3093: 0x2000, 0x3094: 0x2000, 0x3095: 0x2000, 0x3096: 0x2000, 0x3097: 0x2000, 0x3098: 0x2000, 0x3099: 0x2000, 0x309a: 0x2000, 0x309b: 0x2000, 0x309c: 0x2000, 0x309d: 0x2000, 0x309e: 0x2000, 0x309f: 0x2000, 0x30a0: 0x2000, 0x30a1: 0x2000, 0x30a2: 0x2000, 0x30a3: 0x2000, 0x30a4: 0x2000, 0x30a5: 0x2000, 0x30a6: 0x2000, 0x30a7: 0x2000, 0x30a8: 0x0040, 0x30a9: 0x0040, 0x30aa: 0x0040, 0x30ab: 0x0040, 0x30ac: 0x0040, 0x30ad: 0x0040, 0x30ae: 0x0040, 0x30af: 0x0040, 0x30b0: 0x0040, 0x30b1: 0x0040, 0x30b2: 0x0040, 0x30b3: 0x0040, 0x30b4: 0x0040, 0x30b5: 0x0040, 0x30b6: 0x0040, 0x30b7: 0x0040, 0x30b8: 0x0040, 0x30b9: 0x0040, 0x30ba: 0x0040, 0x30bb: 0x0040, 0x30bc: 0x0040, 0x30bd: 0x0040, 0x30be: 0x0040, 0x30bf: 0x0040, // Block 0xc3, offset 0x30c0 0x30c0: 0x0040, 0x30c1: 0x0040, 0x30c2: 0x0040, 0x30c3: 0x0040, 0x30c4: 0x0040, 0x30c5: 0x0040, 0x30c6: 0x0040, 0x30c7: 0x0040, 0x30c8: 0x0040, 0x30c9: 0x0040, 0x30ca: 0x0040, 0x30cb: 0x0040, 0x30cc: 0x0040, 0x30cd: 0x0040, 0x30ce: 0x0040, 0x30cf: 0x0040, 0x30d0: 0x0100, 0x30d1: 0x0100, 0x30d2: 0x0100, 0x30d3: 0x0100, 0x30d4: 0x0100, 0x30d5: 0x0100, 0x30d6: 0x0100, 0x30d7: 0x0100, 0x30d8: 0x0100, 0x30d9: 0x0100, 0x30da: 0x0100, 0x30db: 0x0100, 0x30dc: 0x0100, 0x30dd: 0x0100, 0x30de: 0x0100, 0x30df: 0x0100, 0x30e0: 0x0100, 0x30e1: 0x0100, 0x30e2: 0x0100, 0x30e3: 0x0100, 0x30e4: 0x0100, 0x30e5: 0x0100, 0x30e6: 0x0100, 0x30e7: 0x0100, 0x30e8: 0x0100, 0x30e9: 0x0100, 0x30ea: 0x0100, 0x30eb: 0x0100, 0x30ec: 0x0100, 0x30ed: 0x0100, 0x30ee: 0x0100, 0x30ef: 0x0100, 0x30f0: 0x0100, 0x30f1: 0x0100, 0x30f2: 0x0100, 0x30f3: 0x0100, 0x30f4: 0x0100, 0x30f5: 0x0100, 0x30f6: 0x0100, 0x30f7: 0x0100, 0x30f8: 0x0100, 0x30f9: 0x0100, 0x30fa: 0x0100, 0x30fb: 0x0100, 0x30fc: 0x0100, 0x30fd: 0x0100, 0x30fe: 0x0100, 0x30ff: 0x0100, // Block 0xc4, offset 0x3100 0x3100: 0x0100, 0x3101: 0x0100, 0x3102: 0x0100, 0x3103: 0x0100, 0x3104: 0x0100, 0x3105: 0x0100, 0x3106: 0x0100, 0x3107: 0x0100, 0x3108: 0x0100, 0x3109: 0x0100, 0x310a: 0x0100, 0x310b: 0x0100, 0x310c: 0x0100, 0x310d: 0x0100, 0x310e: 0x0100, 0x310f: 0x0100, 0x3110: 0x0100, 0x3111: 0x0100, 0x3112: 0x0100, 0x3113: 0x0100, 0x3114: 0x0100, 0x3115: 0x0100, 0x3116: 0x0100, 0x3117: 0x0100, 0x3118: 0x0100, 0x3119: 0x0100, 0x311a: 0x0100, 0x311b: 0x0100, 0x311c: 0x0100, 0x311d: 0x0100, 0x3120: 0x0080, 0x3121: 0x0080, 0x3122: 0x0080, 0x3123: 0x0080, 0x3124: 0x0080, 0x3125: 0x0080, 0x3126: 0x0080, 0x3127: 0x0080, 0x3128: 0x0080, 0x3129: 0x0080, 0x3130: 0x2000, 0x3131: 0x2000, 0x3132: 0x2000, 0x3133: 0x2000, 0x3134: 0x2000, 0x3135: 0x2000, 0x3136: 0x2000, 0x3137: 0x2000, 0x3138: 0x2000, 0x3139: 0x2000, 0x313a: 0x2000, 0x313b: 0x2000, 0x313c: 0x2000, 0x313d: 0x2000, 0x313e: 0x2000, 0x313f: 0x2000, // Block 0xc5, offset 0x3140 0x3140: 0x2000, 0x3141: 0x2000, 0x3142: 0x2000, 0x3143: 0x2000, 0x3144: 0x2000, 0x3145: 0x2000, 0x3146: 0x2000, 0x3147: 0x2000, 0x3148: 0x2000, 0x3149: 0x2000, 0x314a: 0x2000, 0x314b: 0x2000, 0x314c: 0x2000, 0x314d: 0x2000, 0x314e: 0x2000, 0x314f: 0x2000, 0x3150: 0x2000, 0x3151: 0x2000, 0x3152: 0x2000, 0x3153: 0x2000, 0x3158: 0x0040, 0x3159: 0x0040, 0x315a: 0x0040, 0x315b: 0x0040, 0x315c: 0x0040, 0x315d: 0x0040, 0x315e: 0x0040, 0x315f: 0x0040, 0x3160: 0x0040, 0x3161: 0x0040, 0x3162: 0x0040, 0x3163: 0x0040, 0x3164: 0x0040, 0x3165: 0x0040, 0x3166: 0x0040, 0x3167: 0x0040, 0x3168: 0x0040, 0x3169: 0x0040, 0x316a: 0x0040, 0x316b: 0x0040, 0x316c: 0x0040, 0x316d: 0x0040, 0x316e: 0x0040, 0x316f: 0x0040, 0x3170: 0x0040, 0x3171: 0x0040, 0x3172: 0x0040, 0x3173: 0x0040, 0x3174: 0x0040, 0x3175: 0x0040, 0x3176: 0x0040, 0x3177: 0x0040, 0x3178: 0x0040, 0x3179: 0x0040, 0x317a: 0x0040, 0x317b: 0x0040, // Block 0xc6, offset 0x3180 0x3180: 0x0100, 0x3181: 0x0100, 0x3182: 0x0100, 0x3183: 0x0100, 0x3184: 0x0100, 0x3185: 0x0100, 0x3186: 0x0100, 0x3187: 0x0100, 0x3188: 0x0100, 0x3189: 0x0100, 0x318a: 0x0100, 0x318b: 0x0100, 0x318c: 0x0100, 0x318d: 0x0100, 0x318e: 0x0100, 0x318f: 0x0100, 0x3190: 0x0100, 0x3191: 0x0100, 0x3192: 0x0100, 0x3193: 0x0100, 0x3194: 0x0100, 0x3195: 0x0100, 0x3196: 0x0100, 0x3197: 0x0100, 0x3198: 0x0100, 0x3199: 0x0100, 0x319a: 0x0100, 0x319b: 0x0100, 0x319c: 0x0100, 0x319d: 0x0100, 0x319e: 0x0100, 0x319f: 0x0100, 0x31a0: 0x0100, 0x31a1: 0x0100, 0x31a2: 0x0100, 0x31a3: 0x0100, 0x31a4: 0x0100, 0x31a5: 0x0100, 0x31a6: 0x0100, 0x31a7: 0x0100, 0x31b0: 0x0100, 0x31b1: 0x0100, 0x31b2: 0x0100, 0x31b3: 0x0100, 0x31b4: 0x0100, 0x31b5: 0x0100, 0x31b6: 0x0100, 0x31b7: 0x0100, 0x31b8: 0x0100, 0x31b9: 0x0100, 0x31ba: 0x0100, 0x31bb: 0x0100, 0x31bc: 0x0100, 0x31bd: 0x0100, 0x31be: 0x0100, 0x31bf: 0x0100, // Block 0xc7, offset 0x31c0 0x31c0: 0x0100, 0x31c1: 0x0100, 0x31c2: 0x0100, 0x31c3: 0x0100, 0x31c4: 0x0100, 0x31c5: 0x0100, 0x31c6: 0x0100, 0x31c7: 0x0100, 0x31c8: 0x0100, 0x31c9: 0x0100, 0x31ca: 0x0100, 0x31cb: 0x0100, 0x31cc: 0x0100, 0x31cd: 0x0100, 0x31ce: 0x0100, 0x31cf: 0x0100, 0x31d0: 0x0100, 0x31d1: 0x0100, 0x31d2: 0x0100, 0x31d3: 0x0100, 0x31d4: 0x0100, 0x31d5: 0x0100, 0x31d6: 0x0100, 0x31d7: 0x0100, 0x31d8: 0x0100, 0x31d9: 0x0100, 0x31da: 0x0100, 0x31db: 0x0100, 0x31dc: 0x0100, 0x31dd: 0x0100, 0x31de: 0x0100, 0x31df: 0x0100, 0x31e0: 0x0100, 0x31e1: 0x0100, 0x31e2: 0x0100, 0x31e3: 0x0100, 0x31f0: 0x2000, 0x31f1: 0x2000, 0x31f2: 0x2000, 0x31f3: 0x2000, 0x31f4: 0x2000, 0x31f5: 0x2000, 0x31f6: 0x2000, 0x31f7: 0x2000, 0x31f8: 0x2000, 0x31f9: 0x2000, 0x31fa: 0x2000, 0x31fc: 0x2000, 0x31fd: 0x2000, 0x31fe: 0x2000, 0x31ff: 0x2000, // Block 0xc8, offset 0x3200 0x3200: 0x2000, 0x3201: 0x2000, 0x3202: 0x2000, 0x3203: 0x2000, 0x3204: 0x2000, 0x3205: 0x2000, 0x3206: 0x2000, 0x3207: 0x2000, 0x3208: 0x2000, 0x3209: 0x2000, 0x320a: 0x2000, 0x320c: 0x2000, 0x320d: 0x2000, 0x320e: 0x2000, 0x320f: 0x2000, 0x3210: 0x2000, 0x3211: 0x2000, 0x3212: 0x2000, 0x3214: 0x2000, 0x3215: 0x2000, 0x3217: 0x0040, 0x3218: 0x0040, 0x3219: 0x0040, 0x321a: 0x0040, 0x321b: 0x0040, 0x321c: 0x0040, 0x321d: 0x0040, 0x321e: 0x0040, 0x321f: 0x0040, 0x3220: 0x0040, 0x3221: 0x0040, 0x3223: 0x0040, 0x3224: 0x0040, 0x3225: 0x0040, 0x3226: 0x0040, 0x3227: 0x0040, 0x3228: 0x0040, 0x3229: 0x0040, 0x322a: 0x0040, 0x322b: 0x0040, 0x322c: 0x0040, 0x322d: 0x0040, 0x322e: 0x0040, 0x322f: 0x0040, 0x3230: 0x0040, 0x3231: 0x0040, 0x3233: 0x0040, 0x3234: 0x0040, 0x3235: 0x0040, 0x3236: 0x0040, 0x3237: 0x0040, 0x3238: 0x0040, 0x3239: 0x0040, 0x323b: 0x0040, 0x323c: 0x0040, // Block 0xc9, offset 0x3240 0x3240: 0x0100, 0x3241: 0x0100, 0x3242: 0x0100, 0x3243: 0x0100, 0x3244: 0x0100, 0x3245: 0x0100, 0x3246: 0x0100, 0x3247: 0x0100, 0x3248: 0x0100, 0x3249: 0x0100, 0x324a: 0x0100, 0x324b: 0x0100, 0x324c: 0x0100, 0x324d: 0x0100, 0x324e: 0x0100, 0x324f: 0x0100, 0x3250: 0x0100, 0x3251: 0x0100, 0x3252: 0x0100, 0x3253: 0x0100, 0x3254: 0x0100, 0x3255: 0x0100, 0x3256: 0x0100, 0x3257: 0x0100, 0x3258: 0x0100, 0x3259: 0x0100, 0x325a: 0x0100, 0x325b: 0x0100, 0x325c: 0x0100, 0x325d: 0x0100, 0x325e: 0x0100, 0x325f: 0x0100, 0x3260: 0x0100, 0x3261: 0x0100, 0x3262: 0x0100, 0x3263: 0x0100, 0x3264: 0x0100, 0x3265: 0x0100, 0x3266: 0x0100, 0x3267: 0x0100, 0x3268: 0x0100, 0x3269: 0x0100, 0x326a: 0x0100, 0x326b: 0x0100, 0x326c: 0x0100, 0x326d: 0x0100, 0x326e: 0x0100, 0x326f: 0x0100, 0x3270: 0x0100, 0x3271: 0x0100, 0x3272: 0x0100, 0x3273: 0x0100, // Block 0xca, offset 0x3280 0x3280: 0x0100, 0x3281: 0x0100, 0x3282: 0x0100, 0x3283: 0x0100, 0x3284: 0x0100, 0x3285: 0x0100, 0x3286: 0x0100, 0x3287: 0x0100, 0x3288: 0x0100, 0x3289: 0x0100, 0x328a: 0x0100, 0x328b: 0x0100, 0x328c: 0x0100, 0x328d: 0x0100, 0x328e: 0x0100, 0x328f: 0x0100, 0x3290: 0x0100, 0x3291: 0x0100, 0x3292: 0x0100, 0x3293: 0x0100, 0x3294: 0x0100, 0x3295: 0x0100, 0x3296: 0x0100, 0x3297: 0x0100, 0x3298: 0x0100, 0x3299: 0x0100, 0x329a: 0x0100, 0x329b: 0x0100, 0x329c: 0x0100, 0x329d: 0x0100, 0x329e: 0x0100, 0x329f: 0x0100, 0x32a0: 0x0100, 0x32a1: 0x0100, 0x32a2: 0x0100, 0x32a3: 0x0100, 0x32a4: 0x0100, 0x32a5: 0x0100, 0x32a6: 0x0100, 0x32a7: 0x0100, 0x32a8: 0x0100, 0x32a9: 0x0100, 0x32aa: 0x0100, 0x32ab: 0x0100, 0x32ac: 0x0100, 0x32ad: 0x0100, 0x32ae: 0x0100, 0x32af: 0x0100, 0x32b0: 0x0100, 0x32b1: 0x0100, 0x32b2: 0x0100, 0x32b3: 0x0100, 0x32b4: 0x0100, 0x32b5: 0x0100, 0x32b6: 0x0100, // Block 0xcb, offset 0x32c0 0x32c0: 0x0100, 0x32c1: 0x0100, 0x32c2: 0x0100, 0x32c3: 0x0100, 0x32c4: 0x0100, 0x32c5: 0x0100, 0x32c6: 0x0100, 0x32c7: 0x0100, 0x32c8: 0x0100, 0x32c9: 0x0100, 0x32ca: 0x0100, 0x32cb: 0x0100, 0x32cc: 0x0100, 0x32cd: 0x0100, 0x32ce: 0x0100, 0x32cf: 0x0100, 0x32d0: 0x0100, 0x32d1: 0x0100, 0x32d2: 0x0100, 0x32d3: 0x0100, 0x32d4: 0x0100, 0x32d5: 0x0100, 0x32e0: 0x0100, 0x32e1: 0x0100, 0x32e2: 0x0100, 0x32e3: 0x0100, 0x32e4: 0x0100, 0x32e5: 0x0100, 0x32e6: 0x0100, 0x32e7: 0x0100, // Block 0xcc, offset 0x3300 0x3300: 0x0040, 0x3301: 0x0100, 0x3302: 0x0100, 0x3303: 0x0040, 0x3304: 0x0040, 0x3305: 0x0040, 0x3307: 0x0040, 0x3308: 0x0040, 0x3309: 0x0040, 0x330a: 0x0040, 0x330b: 0x0040, 0x330c: 0x0040, 0x330d: 0x0040, 0x330e: 0x0040, 0x330f: 0x0040, 0x3310: 0x0040, 0x3311: 0x0040, 0x3312: 0x0040, 0x3313: 0x0040, 0x3314: 0x0040, 0x3315: 0x0040, 0x3316: 0x0040, 0x3317: 0x0040, 0x3318: 0x0040, 0x3319: 0x0040, 0x331a: 0x0040, 0x331b: 0x0040, 0x331c: 0x0040, 0x331d: 0x0040, 0x331e: 0x0040, 0x331f: 0x0040, 0x3320: 0x0040, 0x3321: 0x0040, 0x3322: 0x0040, 0x3323: 0x0040, 0x3324: 0x0040, 0x3325: 0x0040, 0x3326: 0x0040, 0x3327: 0x0040, 0x3328: 0x0040, 0x3329: 0x0040, 0x332a: 0x0040, 0x332b: 0x0040, 0x332c: 0x0040, 0x332d: 0x0040, 0x332e: 0x0040, 0x332f: 0x0040, 0x3330: 0x0040, 0x3332: 0x0040, 0x3333: 0x0040, 0x3334: 0x0040, 0x3335: 0x0040, 0x3336: 0x0040, 0x3337: 0x0040, 0x3338: 0x0040, 0x3339: 0x0040, 0x333a: 0x0040, // Block 0xcd, offset 0x3340 0x3340: 0x0100, 0x3341: 0x0100, 0x3342: 0x0100, 0x3343: 0x0100, 0x3344: 0x0100, 0x3345: 0x0100, 0x3348: 0x0100, 0x334a: 0x0100, 0x334b: 0x0100, 0x334c: 0x0100, 0x334d: 0x0100, 0x334e: 0x0100, 0x334f: 0x0100, 0x3350: 0x0100, 0x3351: 0x0100, 0x3352: 0x0100, 0x3353: 0x0100, 0x3354: 0x0100, 0x3355: 0x0100, 0x3356: 0x0100, 0x3357: 0x0100, 0x3358: 0x0100, 0x3359: 0x0100, 0x335a: 0x0100, 0x335b: 0x0100, 0x335c: 0x0100, 0x335d: 0x0100, 0x335e: 0x0100, 0x335f: 0x0100, 0x3360: 0x0100, 0x3361: 0x0100, 0x3362: 0x0100, 0x3363: 0x0100, 0x3364: 0x0100, 0x3365: 0x0100, 0x3366: 0x0100, 0x3367: 0x0100, 0x3368: 0x0100, 0x3369: 0x0100, 0x336a: 0x0100, 0x336b: 0x0100, 0x336c: 0x0100, 0x336d: 0x0100, 0x336e: 0x0100, 0x336f: 0x0100, 0x3370: 0x0100, 0x3371: 0x0100, 0x3372: 0x0100, 0x3373: 0x0100, 0x3374: 0x0100, 0x3375: 0x0100, 0x3377: 0x0100, 0x3378: 0x0100, 0x337c: 0x0100, 0x337f: 0x0100, // Block 0xce, offset 0x3380 0x3380: 0x0100, 0x3381: 0x0100, 0x3382: 0x0100, 0x3383: 0x0100, 0x3384: 0x0100, 0x3385: 0x0100, 0x3386: 0x0100, 0x3387: 0x0100, 0x3388: 0x0100, 0x3389: 0x0100, 0x338a: 0x0100, 0x338b: 0x0100, 0x338c: 0x0100, 0x338d: 0x0100, 0x338e: 0x0100, 0x338f: 0x0100, 0x3390: 0x0100, 0x3391: 0x0100, 0x3392: 0x0100, 0x3393: 0x0100, 0x3394: 0x0100, 0x3395: 0x0100, 0x33a0: 0x0100, 0x33a1: 0x0100, 0x33a2: 0x0100, 0x33a3: 0x0100, 0x33a4: 0x0100, 0x33a5: 0x0100, 0x33a6: 0x0100, 0x33a7: 0x0100, 0x33a8: 0x0100, 0x33a9: 0x0100, 0x33aa: 0x0100, 0x33ab: 0x0100, 0x33ac: 0x0100, 0x33ad: 0x0100, 0x33ae: 0x0100, 0x33af: 0x0100, 0x33b0: 0x0100, 0x33b1: 0x0100, 0x33b2: 0x0100, 0x33b3: 0x0100, 0x33b4: 0x0100, 0x33b5: 0x0100, 0x33b6: 0x0100, // Block 0xcf, offset 0x33c0 0x33c0: 0x0100, 0x33c1: 0x0100, 0x33c2: 0x0100, 0x33c3: 0x0100, 0x33c4: 0x0100, 0x33c5: 0x0100, 0x33c6: 0x0100, 0x33c7: 0x0100, 0x33c8: 0x0100, 0x33c9: 0x0100, 0x33ca: 0x0100, 0x33cb: 0x0100, 0x33cc: 0x0100, 0x33cd: 0x0100, 0x33ce: 0x0100, 0x33cf: 0x0100, 0x33d0: 0x0100, 0x33d1: 0x0100, 0x33d2: 0x0100, 0x33d3: 0x0100, 0x33d4: 0x0100, 0x33d5: 0x0100, 0x33d6: 0x0100, 0x33d7: 0x0100, 0x33d8: 0x0100, 0x33d9: 0x0100, 0x33da: 0x0100, 0x33db: 0x0100, 0x33dc: 0x0100, 0x33dd: 0x0100, 0x33de: 0x0100, // Block 0xd0, offset 0x3400 0x3420: 0x0100, 0x3421: 0x0100, 0x3422: 0x0100, 0x3423: 0x0100, 0x3424: 0x0100, 0x3425: 0x0100, 0x3426: 0x0100, 0x3427: 0x0100, 0x3428: 0x0100, 0x3429: 0x0100, 0x342a: 0x0100, 0x342b: 0x0100, 0x342c: 0x0100, 0x342d: 0x0100, 0x342e: 0x0100, 0x342f: 0x0100, 0x3430: 0x0100, 0x3431: 0x0100, 0x3432: 0x0100, 0x3434: 0x0100, 0x3435: 0x0100, // Block 0xd1, offset 0x3440 0x3440: 0x0100, 0x3441: 0x0100, 0x3442: 0x0100, 0x3443: 0x0100, 0x3444: 0x0100, 0x3445: 0x0100, 0x3446: 0x0100, 0x3447: 0x0100, 0x3448: 0x0100, 0x3449: 0x0100, 0x344a: 0x0100, 0x344b: 0x0100, 0x344c: 0x0100, 0x344d: 0x0100, 0x344e: 0x0100, 0x344f: 0x0100, 0x3450: 0x0100, 0x3451: 0x0100, 0x3452: 0x0100, 0x3453: 0x0100, 0x3454: 0x0100, 0x3455: 0x0100, 0x3460: 0x0100, 0x3461: 0x0100, 0x3462: 0x0100, 0x3463: 0x0100, 0x3464: 0x0100, 0x3465: 0x0100, 0x3466: 0x0100, 0x3467: 0x0100, 0x3468: 0x0100, 0x3469: 0x0100, 0x346a: 0x0100, 0x346b: 0x0100, 0x346c: 0x0100, 0x346d: 0x0100, 0x346e: 0x0100, 0x346f: 0x0100, 0x3470: 0x0100, 0x3471: 0x0100, 0x3472: 0x0100, 0x3473: 0x0100, 0x3474: 0x0100, 0x3475: 0x0100, 0x3476: 0x0100, 0x3477: 0x0100, 0x3478: 0x0100, 0x3479: 0x0100, // Block 0xd2, offset 0x3480 0x3480: 0x0100, 0x3481: 0x0100, 0x3482: 0x0100, 0x3483: 0x0100, 0x3484: 0x0100, 0x3485: 0x0100, 0x3486: 0x0100, 0x3487: 0x0100, 0x3488: 0x0100, 0x3489: 0x0100, 0x348a: 0x0100, 0x348b: 0x0100, 0x348c: 0x0100, 0x348d: 0x0100, 0x348e: 0x0100, 0x348f: 0x0100, 0x3490: 0x0100, 0x3491: 0x0100, 0x3492: 0x0100, 0x3493: 0x0100, 0x3494: 0x0100, 0x3495: 0x0100, 0x3496: 0x0100, 0x3497: 0x0100, 0x3498: 0x0100, 0x3499: 0x0100, 0x349a: 0x0100, 0x349b: 0x0100, 0x349c: 0x0100, 0x349d: 0x0100, 0x349e: 0x0100, 0x349f: 0x0100, 0x34a0: 0x0100, 0x34a1: 0x0100, 0x34a2: 0x0100, 0x34a3: 0x0100, 0x34a4: 0x0100, 0x34a5: 0x0100, 0x34a6: 0x0100, 0x34a7: 0x0100, 0x34a8: 0x0100, 0x34a9: 0x0100, 0x34aa: 0x0100, 0x34ab: 0x0100, 0x34ac: 0x0100, 0x34ad: 0x0100, 0x34ae: 0x0100, 0x34af: 0x0100, 0x34b0: 0x0100, 0x34b1: 0x0100, 0x34b2: 0x0100, 0x34b3: 0x0100, 0x34b4: 0x0100, 0x34b5: 0x0100, 0x34b6: 0x0100, 0x34b7: 0x0100, 0x34be: 0x0100, 0x34bf: 0x0100, // Block 0xd3, offset 0x34c0 0x34c0: 0x0100, 0x34c1: 0x0008, 0x34c2: 0x0008, 0x34c3: 0x0008, 0x34c5: 0x0008, 0x34c6: 0x0008, 0x34cc: 0x0008, 0x34cd: 0x0008, 0x34ce: 0x0008, 0x34cf: 0x0008, 0x34d0: 0x0100, 0x34d1: 0x0100, 0x34d2: 0x0100, 0x34d3: 0x0100, 0x34d5: 0x0100, 0x34d6: 0x0100, 0x34d7: 0x0100, 0x34d9: 0x0100, 0x34da: 0x0100, 0x34db: 0x0100, 0x34dc: 0x0100, 0x34dd: 0x0100, 0x34de: 0x0100, 0x34df: 0x0100, 0x34e0: 0x0100, 0x34e1: 0x0100, 0x34e2: 0x0100, 0x34e3: 0x0100, 0x34e4: 0x0100, 0x34e5: 0x0100, 0x34e6: 0x0100, 0x34e7: 0x0100, 0x34e8: 0x0100, 0x34e9: 0x0100, 0x34ea: 0x0100, 0x34eb: 0x0100, 0x34ec: 0x0100, 0x34ed: 0x0100, 0x34ee: 0x0100, 0x34ef: 0x0100, 0x34f0: 0x0100, 0x34f1: 0x0100, 0x34f2: 0x0100, 0x34f3: 0x0100, 0x34f4: 0x0100, 0x34f5: 0x0100, 0x34f8: 0x0008, 0x34f9: 0x0008, 0x34fa: 0x0008, 0x34ff: 0x0008, // Block 0xd4, offset 0x3500 0x3516: 0x0400, 0x3517: 0x0400, 0x3520: 0x0100, 0x3521: 0x0100, 0x3522: 0x0100, 0x3523: 0x0100, 0x3524: 0x0100, 0x3525: 0x0100, 0x3526: 0x0100, 0x3527: 0x0100, 0x3528: 0x0100, 0x3529: 0x0100, 0x352a: 0x0100, 0x352b: 0x0100, 0x352c: 0x0100, 0x352d: 0x0100, 0x352e: 0x0100, 0x352f: 0x0100, 0x3530: 0x0100, 0x3531: 0x0100, 0x3532: 0x0100, 0x3533: 0x0100, 0x3534: 0x0100, 0x3535: 0x0100, 0x3536: 0x0100, 0x3537: 0x0100, 0x3538: 0x0100, 0x3539: 0x0100, 0x353a: 0x0100, 0x353b: 0x0100, 0x353c: 0x0100, // Block 0xd5, offset 0x3540 0x3540: 0x0100, 0x3541: 0x0100, 0x3542: 0x0100, 0x3543: 0x0100, 0x3544: 0x0100, 0x3545: 0x0100, 0x3546: 0x0100, 0x3547: 0x0100, 0x3548: 0x0100, 0x3549: 0x0100, 0x354a: 0x0100, 0x354b: 0x0100, 0x354c: 0x0100, 0x354d: 0x0100, 0x354e: 0x0100, 0x354f: 0x0100, 0x3550: 0x0100, 0x3551: 0x0100, 0x3552: 0x0100, 0x3553: 0x0100, 0x3554: 0x0100, 0x3555: 0x0100, 0x3556: 0x0100, 0x3557: 0x0100, 0x3558: 0x0100, 0x3559: 0x0100, 0x355a: 0x0100, 0x355b: 0x0100, 0x355c: 0x0100, // Block 0xd6, offset 0x3580 0x3580: 0x0100, 0x3581: 0x0100, 0x3582: 0x0100, 0x3583: 0x0100, 0x3584: 0x0100, 0x3585: 0x0100, 0x3586: 0x0100, 0x3587: 0x0100, 0x3589: 0x0100, 0x358a: 0x0100, 0x358b: 0x0100, 0x358c: 0x0100, 0x358d: 0x0100, 0x358e: 0x0100, 0x358f: 0x0100, 0x3590: 0x0100, 0x3591: 0x0100, 0x3592: 0x0100, 0x3593: 0x0100, 0x3594: 0x0100, 0x3595: 0x0100, 0x3596: 0x0100, 0x3597: 0x0100, 0x3598: 0x0100, 0x3599: 0x0100, 0x359a: 0x0100, 0x359b: 0x0100, 0x359c: 0x0100, 0x359d: 0x0100, 0x359e: 0x0100, 0x359f: 0x0100, 0x35a0: 0x0100, 0x35a1: 0x0100, 0x35a2: 0x0100, 0x35a3: 0x0100, 0x35a4: 0x0100, 0x35a5: 0x0008, 0x35a6: 0x0008, // Block 0xd7, offset 0x35c0 0x35c0: 0x0100, 0x35c1: 0x0100, 0x35c2: 0x0100, 0x35c3: 0x0100, 0x35c4: 0x0100, 0x35c5: 0x0100, 0x35c6: 0x0100, 0x35c7: 0x0100, 0x35c8: 0x0100, 0x35c9: 0x0100, 0x35ca: 0x0100, 0x35cb: 0x0100, 0x35cc: 0x0100, 0x35cd: 0x0100, 0x35ce: 0x0100, 0x35cf: 0x0100, 0x35d0: 0x0100, 0x35d1: 0x0100, 0x35d2: 0x0100, 0x35d3: 0x0100, 0x35d4: 0x0100, 0x35d5: 0x0100, 0x35e0: 0x0100, 0x35e1: 0x0100, 0x35e2: 0x0100, 0x35e3: 0x0100, 0x35e4: 0x0100, 0x35e5: 0x0100, 0x35e6: 0x0100, 0x35e7: 0x0100, 0x35e8: 0x0100, 0x35e9: 0x0100, 0x35ea: 0x0100, 0x35eb: 0x0100, 0x35ec: 0x0100, 0x35ed: 0x0100, 0x35ee: 0x0100, 0x35ef: 0x0100, 0x35f0: 0x0100, 0x35f1: 0x0100, 0x35f2: 0x0100, // Block 0xd8, offset 0x3600 0x3600: 0x0100, 0x3601: 0x0100, 0x3602: 0x0100, 0x3603: 0x0100, 0x3604: 0x0100, 0x3605: 0x0100, 0x3606: 0x0100, 0x3607: 0x0100, 0x3608: 0x0100, 0x3609: 0x0100, 0x360a: 0x0100, 0x360b: 0x0100, 0x360c: 0x0100, 0x360d: 0x0100, 0x360e: 0x0100, 0x360f: 0x0100, 0x3610: 0x0100, 0x3611: 0x0100, // Block 0xd9, offset 0x3640 0x3640: 0x0100, 0x3641: 0x0100, 0x3642: 0x0100, 0x3643: 0x0100, 0x3644: 0x0100, 0x3645: 0x0100, 0x3646: 0x0100, 0x3647: 0x0100, 0x3648: 0x0100, // Block 0xda, offset 0x3680 0x3680: 0x2000, 0x3681: 0x2000, 0x3682: 0x2000, 0x3683: 0x2000, 0x3684: 0x2000, 0x3685: 0x2000, 0x3686: 0x2000, 0x3687: 0x2000, 0x3688: 0x2000, 0x3689: 0x2000, 0x368a: 0x2000, 0x368b: 0x2000, 0x368c: 0x2000, 0x368d: 0x2000, 0x368e: 0x2000, 0x368f: 0x2000, 0x3690: 0x2000, 0x3691: 0x2000, 0x3692: 0x2000, 0x3693: 0x2000, 0x3694: 0x2000, 0x3695: 0x2000, 0x3696: 0x2000, 0x3697: 0x2000, 0x3698: 0x2000, 0x3699: 0x2000, 0x369a: 0x2000, 0x369b: 0x2000, 0x369c: 0x2000, 0x369d: 0x2000, 0x369e: 0x2000, 0x369f: 0x2000, 0x36a0: 0x2000, 0x36a1: 0x2000, 0x36a2: 0x2000, 0x36a3: 0x2000, 0x36a4: 0x2000, 0x36a5: 0x2000, 0x36a6: 0x2000, 0x36a7: 0x2000, 0x36a8: 0x2000, 0x36a9: 0x2000, 0x36aa: 0x2000, 0x36ab: 0x2000, 0x36ac: 0x2000, 0x36ad: 0x2000, 0x36ae: 0x2000, 0x36af: 0x2000, 0x36b0: 0x2000, 0x36b1: 0x2000, 0x36b2: 0x2000, // Block 0xdb, offset 0x36c0 0x36c0: 0x0040, 0x36c1: 0x0040, 0x36c2: 0x0040, 0x36c3: 0x0040, 0x36c4: 0x0040, 0x36c5: 0x0040, 0x36c6: 0x0040, 0x36c7: 0x0040, 0x36c8: 0x0040, 0x36c9: 0x0040, 0x36ca: 0x0040, 0x36cb: 0x0040, 0x36cc: 0x0040, 0x36cd: 0x0040, 0x36ce: 0x0040, 0x36cf: 0x0040, 0x36d0: 0x0040, 0x36d1: 0x0040, 0x36d2: 0x0040, 0x36d3: 0x0040, 0x36d4: 0x0040, 0x36d5: 0x0040, 0x36d6: 0x0040, 0x36d7: 0x0040, 0x36d8: 0x0040, 0x36d9: 0x0040, 0x36da: 0x0040, 0x36db: 0x0040, 0x36dc: 0x0040, 0x36dd: 0x0040, 0x36de: 0x0040, 0x36df: 0x0040, 0x36e0: 0x0040, 0x36e1: 0x0040, 0x36e2: 0x0040, 0x36e3: 0x0040, 0x36e4: 0x0040, 0x36e5: 0x0040, 0x36e6: 0x0040, 0x36e7: 0x0040, 0x36e8: 0x0040, 0x36e9: 0x0040, 0x36ea: 0x0040, 0x36eb: 0x0040, 0x36ec: 0x0040, 0x36ed: 0x0040, 0x36ee: 0x0040, 0x36ef: 0x0040, 0x36f0: 0x0040, 0x36f1: 0x0040, 0x36f2: 0x0040, // Block 0xdc, offset 0x3700 0x3700: 0x0100, 0x3701: 0x0100, 0x3702: 0x0100, 0x3703: 0x0100, 0x3704: 0x0100, 0x3705: 0x0100, 0x3706: 0x0100, 0x3707: 0x0100, 0x3708: 0x0100, 0x3709: 0x0100, 0x370a: 0x0100, 0x370b: 0x0100, 0x370c: 0x0100, 0x370d: 0x0100, 0x370e: 0x0100, 0x370f: 0x0100, 0x3710: 0x0100, 0x3711: 0x0100, 0x3712: 0x0100, 0x3713: 0x0100, 0x3714: 0x0100, 0x3715: 0x0100, 0x3716: 0x0100, 0x3717: 0x0100, 0x3718: 0x0100, 0x3719: 0x0100, 0x371a: 0x0100, 0x371b: 0x0100, 0x371c: 0x0100, 0x371d: 0x0100, 0x371e: 0x0100, 0x371f: 0x0100, 0x3720: 0x0100, 0x3721: 0x0100, 0x3722: 0x0100, 0x3723: 0x0100, 0x3724: 0x0008, 0x3725: 0x0008, 0x3726: 0x0008, 0x3727: 0x0008, 0x3730: 0x0080, 0x3731: 0x0080, 0x3732: 0x0080, 0x3733: 0x0080, 0x3734: 0x0080, 0x3735: 0x0080, 0x3736: 0x0080, 0x3737: 0x0080, 0x3738: 0x0080, 0x3739: 0x0080, // Block 0xdd, offset 0x3740 0x3740: 0x0080, 0x3741: 0x0080, 0x3742: 0x0080, 0x3743: 0x0080, 0x3744: 0x0080, 0x3745: 0x0080, 0x3746: 0x0080, 0x3747: 0x0080, 0x3748: 0x0080, 0x3749: 0x0080, 0x374a: 0x0100, 0x374b: 0x0100, 0x374c: 0x0100, 0x374d: 0x0100, 0x374e: 0x0100, 0x374f: 0x0100, 0x3750: 0x2000, 0x3751: 0x2000, 0x3752: 0x2000, 0x3753: 0x2000, 0x3754: 0x2000, 0x3755: 0x2000, 0x3756: 0x2000, 0x3757: 0x2000, 0x3758: 0x2000, 0x3759: 0x2000, 0x375a: 0x2000, 0x375b: 0x2000, 0x375c: 0x2000, 0x375d: 0x2000, 0x375e: 0x2000, 0x375f: 0x2000, 0x3760: 0x2000, 0x3761: 0x2000, 0x3762: 0x2000, 0x3763: 0x2000, 0x3764: 0x2000, 0x3765: 0x2000, 0x3769: 0x0008, 0x376a: 0x0008, 0x376b: 0x0008, 0x376c: 0x0008, 0x376d: 0x0008, 0x376f: 0x0100, 0x3770: 0x0040, 0x3771: 0x0040, 0x3772: 0x0040, 0x3773: 0x0040, 0x3774: 0x0040, 0x3775: 0x0040, 0x3776: 0x0040, 0x3777: 0x0040, 0x3778: 0x0040, 0x3779: 0x0040, 0x377a: 0x0040, 0x377b: 0x0040, 0x377c: 0x0040, 0x377d: 0x0040, 0x377e: 0x0040, 0x377f: 0x0040, // Block 0xde, offset 0x3780 0x3780: 0x0040, 0x3781: 0x0040, 0x3782: 0x0040, 0x3783: 0x0040, 0x3784: 0x0040, 0x3785: 0x0040, // Block 0xdf, offset 0x37c0 0x37c0: 0x0100, 0x37c1: 0x0100, 0x37c2: 0x0100, 0x37c3: 0x0100, 0x37c4: 0x0100, 0x37c5: 0x0100, 0x37c6: 0x0100, 0x37c7: 0x0100, 0x37c8: 0x0100, 0x37c9: 0x0100, 0x37ca: 0x0100, 0x37cb: 0x0100, 0x37cc: 0x0100, 0x37cd: 0x0100, 0x37ce: 0x0100, 0x37cf: 0x0100, 0x37d0: 0x0100, 0x37d1: 0x0100, 0x37d2: 0x0100, 0x37d3: 0x0100, 0x37d4: 0x0100, 0x37d5: 0x0100, 0x37d6: 0x0100, 0x37d7: 0x0100, 0x37d8: 0x0100, 0x37d9: 0x0100, 0x37da: 0x0100, 0x37db: 0x0100, 0x37dc: 0x0100, 0x37dd: 0x0100, 0x37de: 0x0100, 0x37df: 0x0100, 0x37e0: 0x0100, 0x37e1: 0x0100, 0x37e2: 0x0100, 0x37e3: 0x0100, 0x37e4: 0x0100, 0x37e5: 0x0100, 0x37e6: 0x0100, 0x37e7: 0x0100, 0x37e8: 0x0100, 0x37e9: 0x0100, 0x37eb: 0x0008, 0x37ec: 0x0008, 0x37f0: 0x0100, 0x37f1: 0x0100, // Block 0xe0, offset 0x3800 0x3802: 0x0100, 0x3803: 0x0100, 0x3804: 0x0100, 0x3805: 0x0100, 0x3806: 0x0100, 0x3807: 0x0100, 0x383a: 0x0008, 0x383b: 0x0008, 0x383c: 0x0008, 0x383d: 0x0008, 0x383e: 0x0008, 0x383f: 0x0008, // Block 0xe1, offset 0x3840 0x3840: 0x0100, 0x3841: 0x0100, 0x3842: 0x0100, 0x3843: 0x0100, 0x3844: 0x0100, 0x3845: 0x0100, 0x3846: 0x0100, 0x3847: 0x0100, 0x3848: 0x0100, 0x3849: 0x0100, 0x384a: 0x0100, 0x384b: 0x0100, 0x384c: 0x0100, 0x384d: 0x0100, 0x384e: 0x0100, 0x384f: 0x0100, 0x3850: 0x0100, 0x3851: 0x0100, 0x3852: 0x0100, 0x3853: 0x0100, 0x3854: 0x0100, 0x3855: 0x0100, 0x3856: 0x0100, 0x3857: 0x0100, 0x3858: 0x0100, 0x3859: 0x0100, 0x385a: 0x0100, 0x385b: 0x0100, 0x385c: 0x0100, 0x3867: 0x0100, 0x3870: 0x0100, 0x3871: 0x0100, 0x3872: 0x0100, 0x3873: 0x0100, 0x3874: 0x0100, 0x3875: 0x0100, 0x3876: 0x0100, 0x3877: 0x0100, 0x3878: 0x0100, 0x3879: 0x0100, 0x387a: 0x0100, 0x387b: 0x0100, 0x387c: 0x0100, 0x387d: 0x0100, 0x387e: 0x0100, 0x387f: 0x0100, // Block 0xe2, offset 0x3880 0x3880: 0x0100, 0x3881: 0x0100, 0x3882: 0x0100, 0x3883: 0x0100, 0x3884: 0x0100, 0x3885: 0x0100, 0x3886: 0x0008, 0x3887: 0x0008, 0x3888: 0x0008, 0x3889: 0x0008, 0x388a: 0x0008, 0x388b: 0x0008, 0x388c: 0x0008, 0x388d: 0x0008, 0x388e: 0x0008, 0x388f: 0x0008, 0x3890: 0x0008, 0x3895: 0x0400, 0x3896: 0x0400, 0x3897: 0x0400, 0x3898: 0x0400, 0x3899: 0x0400, 0x38b0: 0x0100, 0x38b1: 0x0100, 0x38b2: 0x0100, 0x38b3: 0x0100, 0x38b4: 0x0100, 0x38b5: 0x0100, 0x38b6: 0x0100, 0x38b7: 0x0100, 0x38b8: 0x0100, 0x38b9: 0x0100, 0x38ba: 0x0100, 0x38bb: 0x0100, 0x38bc: 0x0100, 0x38bd: 0x0100, 0x38be: 0x0100, 0x38bf: 0x0100, // Block 0xe3, offset 0x38c0 0x38c0: 0x0100, 0x38c1: 0x0100, 0x38c2: 0x0008, 0x38c3: 0x0008, 0x38c4: 0x0008, 0x38c5: 0x0008, 0x38c6: 0x0400, 0x38c7: 0x0400, 0x38c8: 0x0400, 0x38c9: 0x0400, 0x38f0: 0x0100, 0x38f1: 0x0100, 0x38f2: 0x0100, 0x38f3: 0x0100, 0x38f4: 0x0100, 0x38f5: 0x0100, 0x38f6: 0x0100, 0x38f7: 0x0100, 0x38f8: 0x0100, 0x38f9: 0x0100, 0x38fa: 0x0100, 0x38fb: 0x0100, 0x38fc: 0x0100, 0x38fd: 0x0100, 0x38fe: 0x0100, 0x38ff: 0x0100, // Block 0xe4, offset 0x3900 0x3900: 0x0100, 0x3901: 0x0100, 0x3902: 0x0100, 0x3903: 0x0100, 0x3904: 0x0100, 0x3920: 0x0100, 0x3921: 0x0100, 0x3922: 0x0100, 0x3923: 0x0100, 0x3924: 0x0100, 0x3925: 0x0100, 0x3926: 0x0100, 0x3927: 0x0100, 0x3928: 0x0100, 0x3929: 0x0100, 0x392a: 0x0100, 0x392b: 0x0100, 0x392c: 0x0100, 0x392d: 0x0100, 0x392e: 0x0100, 0x392f: 0x0100, 0x3930: 0x0100, 0x3931: 0x0100, 0x3932: 0x0100, 0x3933: 0x0100, 0x3934: 0x0100, 0x3935: 0x0100, 0x3936: 0x0100, // Block 0xe5, offset 0x3940 0x3940: 0x0008, 0x3941: 0x0008, 0x3942: 0x0008, 0x3943: 0x0100, 0x3944: 0x0100, 0x3945: 0x0100, 0x3946: 0x0100, 0x3947: 0x0100, 0x3948: 0x0100, 0x3949: 0x0100, 0x394a: 0x0100, 0x394b: 0x0100, 0x394c: 0x0100, 0x394d: 0x0100, 0x394e: 0x0100, 0x394f: 0x0100, 0x3950: 0x0100, 0x3951: 0x0100, 0x3952: 0x0100, 0x3953: 0x0100, 0x3954: 0x0100, 0x3955: 0x0100, 0x3956: 0x0100, 0x3957: 0x0100, 0x3958: 0x0100, 0x3959: 0x0100, 0x395a: 0x0100, 0x395b: 0x0100, 0x395c: 0x0100, 0x395d: 0x0100, 0x395e: 0x0100, 0x395f: 0x0100, 0x3960: 0x0100, 0x3961: 0x0100, 0x3962: 0x0100, 0x3963: 0x0100, 0x3964: 0x0100, 0x3965: 0x0100, 0x3966: 0x0100, 0x3967: 0x0100, 0x3968: 0x0100, 0x3969: 0x0100, 0x396a: 0x0100, 0x396b: 0x0100, 0x396c: 0x0100, 0x396d: 0x0100, 0x396e: 0x0100, 0x396f: 0x0100, 0x3970: 0x0100, 0x3971: 0x0100, 0x3972: 0x0100, 0x3973: 0x0100, 0x3974: 0x0100, 0x3975: 0x0100, 0x3976: 0x0100, 0x3977: 0x0100, 0x3978: 0x0008, 0x3979: 0x0008, 0x397a: 0x0008, 0x397b: 0x0008, 0x397c: 0x0008, 0x397d: 0x0008, 0x397e: 0x0008, 0x397f: 0x0008, // Block 0xe6, offset 0x3980 0x3980: 0x0008, 0x3981: 0x0008, 0x3982: 0x0008, 0x3983: 0x0008, 0x3984: 0x0008, 0x3985: 0x0008, 0x3986: 0x0008, 0x3987: 0x0400, 0x3988: 0x0400, 0x39a6: 0x0080, 0x39a7: 0x0080, 0x39a8: 0x0080, 0x39a9: 0x0080, 0x39aa: 0x0080, 0x39ab: 0x0080, 0x39ac: 0x0080, 0x39ad: 0x0080, 0x39ae: 0x0080, 0x39af: 0x0080, 0x39b0: 0x0008, 0x39b1: 0x0100, 0x39b2: 0x0100, 0x39b3: 0x0008, 0x39b4: 0x0008, 0x39b5: 0x0100, 0x39bf: 0x0008, // Block 0xe7, offset 0x39c0 0x39c0: 0x0008, 0x39c1: 0x0008, 0x39c2: 0x0008, 0x39c3: 0x0100, 0x39c4: 0x0100, 0x39c5: 0x0100, 0x39c6: 0x0100, 0x39c7: 0x0100, 0x39c8: 0x0100, 0x39c9: 0x0100, 0x39ca: 0x0100, 0x39cb: 0x0100, 0x39cc: 0x0100, 0x39cd: 0x0100, 0x39ce: 0x0100, 0x39cf: 0x0100, 0x39d0: 0x0100, 0x39d1: 0x0100, 0x39d2: 0x0100, 0x39d3: 0x0100, 0x39d4: 0x0100, 0x39d5: 0x0100, 0x39d6: 0x0100, 0x39d7: 0x0100, 0x39d8: 0x0100, 0x39d9: 0x0100, 0x39da: 0x0100, 0x39db: 0x0100, 0x39dc: 0x0100, 0x39dd: 0x0100, 0x39de: 0x0100, 0x39df: 0x0100, 0x39e0: 0x0100, 0x39e1: 0x0100, 0x39e2: 0x0100, 0x39e3: 0x0100, 0x39e4: 0x0100, 0x39e5: 0x0100, 0x39e6: 0x0100, 0x39e7: 0x0100, 0x39e8: 0x0100, 0x39e9: 0x0100, 0x39ea: 0x0100, 0x39eb: 0x0100, 0x39ec: 0x0100, 0x39ed: 0x0100, 0x39ee: 0x0100, 0x39ef: 0x0100, 0x39f0: 0x0008, 0x39f1: 0x0008, 0x39f2: 0x0008, 0x39f3: 0x0008, 0x39f4: 0x0008, 0x39f5: 0x0008, 0x39f6: 0x0008, 0x39f7: 0x0008, 0x39f8: 0x0008, 0x39f9: 0x0008, 0x39fa: 0x0008, 0x39fd: 0x0080, 0x39fe: 0x0400, 0x39ff: 0x0400, // Block 0xe8, offset 0x3a00 0x3a00: 0x0400, 0x3a01: 0x0400, 0x3a02: 0x0008, 0x3a0d: 0x0080, 0x3a10: 0x0100, 0x3a11: 0x0100, 0x3a12: 0x0100, 0x3a13: 0x0100, 0x3a14: 0x0100, 0x3a15: 0x0100, 0x3a16: 0x0100, 0x3a17: 0x0100, 0x3a18: 0x0100, 0x3a19: 0x0100, 0x3a1a: 0x0100, 0x3a1b: 0x0100, 0x3a1c: 0x0100, 0x3a1d: 0x0100, 0x3a1e: 0x0100, 0x3a1f: 0x0100, 0x3a20: 0x0100, 0x3a21: 0x0100, 0x3a22: 0x0100, 0x3a23: 0x0100, 0x3a24: 0x0100, 0x3a25: 0x0100, 0x3a26: 0x0100, 0x3a27: 0x0100, 0x3a28: 0x0100, 0x3a30: 0x0080, 0x3a31: 0x0080, 0x3a32: 0x0080, 0x3a33: 0x0080, 0x3a34: 0x0080, 0x3a35: 0x0080, 0x3a36: 0x0080, 0x3a37: 0x0080, 0x3a38: 0x0080, 0x3a39: 0x0080, // Block 0xe9, offset 0x3a40 0x3a40: 0x0008, 0x3a41: 0x0008, 0x3a42: 0x0008, 0x3a43: 0x0100, 0x3a44: 0x0100, 0x3a45: 0x0100, 0x3a46: 0x0100, 0x3a47: 0x0100, 0x3a48: 0x0100, 0x3a49: 0x0100, 0x3a4a: 0x0100, 0x3a4b: 0x0100, 0x3a4c: 0x0100, 0x3a4d: 0x0100, 0x3a4e: 0x0100, 0x3a4f: 0x0100, 0x3a50: 0x0100, 0x3a51: 0x0100, 0x3a52: 0x0100, 0x3a53: 0x0100, 0x3a54: 0x0100, 0x3a55: 0x0100, 0x3a56: 0x0100, 0x3a57: 0x0100, 0x3a58: 0x0100, 0x3a59: 0x0100, 0x3a5a: 0x0100, 0x3a5b: 0x0100, 0x3a5c: 0x0100, 0x3a5d: 0x0100, 0x3a5e: 0x0100, 0x3a5f: 0x0100, 0x3a60: 0x0100, 0x3a61: 0x0100, 0x3a62: 0x0100, 0x3a63: 0x0100, 0x3a64: 0x0100, 0x3a65: 0x0100, 0x3a66: 0x0100, 0x3a67: 0x0008, 0x3a68: 0x0008, 0x3a69: 0x0008, 0x3a6a: 0x0008, 0x3a6b: 0x0008, 0x3a6c: 0x0008, 0x3a6d: 0x0008, 0x3a6e: 0x0008, 0x3a6f: 0x0008, 0x3a70: 0x0008, 0x3a71: 0x0008, 0x3a72: 0x0008, 0x3a73: 0x0008, 0x3a74: 0x0008, 0x3a76: 0x0080, 0x3a77: 0x0080, 0x3a78: 0x0080, 0x3a79: 0x0080, 0x3a7a: 0x0080, 0x3a7b: 0x0080, 0x3a7c: 0x0080, 0x3a7d: 0x0080, 0x3a7e: 0x0080, 0x3a7f: 0x0080, // Block 0xea, offset 0x3a80 0x3a81: 0x0400, 0x3a82: 0x0400, 0x3a83: 0x0400, 0x3a84: 0x0100, 0x3a85: 0x0008, 0x3a86: 0x0008, 0x3a87: 0x0100, 0x3a90: 0x0100, 0x3a91: 0x0100, 0x3a92: 0x0100, 0x3a93: 0x0100, 0x3a94: 0x0100, 0x3a95: 0x0100, 0x3a96: 0x0100, 0x3a97: 0x0100, 0x3a98: 0x0100, 0x3a99: 0x0100, 0x3a9a: 0x0100, 0x3a9b: 0x0100, 0x3a9c: 0x0100, 0x3a9d: 0x0100, 0x3a9e: 0x0100, 0x3a9f: 0x0100, 0x3aa0: 0x0100, 0x3aa1: 0x0100, 0x3aa2: 0x0100, 0x3aa3: 0x0100, 0x3aa4: 0x0100, 0x3aa5: 0x0100, 0x3aa6: 0x0100, 0x3aa7: 0x0100, 0x3aa8: 0x0100, 0x3aa9: 0x0100, 0x3aaa: 0x0100, 0x3aab: 0x0100, 0x3aac: 0x0100, 0x3aad: 0x0100, 0x3aae: 0x0100, 0x3aaf: 0x0100, 0x3ab0: 0x0100, 0x3ab1: 0x0100, 0x3ab2: 0x0100, 0x3ab3: 0x0008, 0x3ab6: 0x0100, // Block 0xeb, offset 0x3ac0 0x3ac0: 0x0008, 0x3ac1: 0x0008, 0x3ac2: 0x0008, 0x3ac3: 0x0100, 0x3ac4: 0x0100, 0x3ac5: 0x0100, 0x3ac6: 0x0100, 0x3ac7: 0x0100, 0x3ac8: 0x0100, 0x3ac9: 0x0100, 0x3aca: 0x0100, 0x3acb: 0x0100, 0x3acc: 0x0100, 0x3acd: 0x0100, 0x3ace: 0x0100, 0x3acf: 0x0100, 0x3ad0: 0x0100, 0x3ad1: 0x0100, 0x3ad2: 0x0100, 0x3ad3: 0x0100, 0x3ad4: 0x0100, 0x3ad5: 0x0100, 0x3ad6: 0x0100, 0x3ad7: 0x0100, 0x3ad8: 0x0100, 0x3ad9: 0x0100, 0x3ada: 0x0100, 0x3adb: 0x0100, 0x3adc: 0x0100, 0x3add: 0x0100, 0x3ade: 0x0100, 0x3adf: 0x0100, 0x3ae0: 0x0100, 0x3ae1: 0x0100, 0x3ae2: 0x0100, 0x3ae3: 0x0100, 0x3ae4: 0x0100, 0x3ae5: 0x0100, 0x3ae6: 0x0100, 0x3ae7: 0x0100, 0x3ae8: 0x0100, 0x3ae9: 0x0100, 0x3aea: 0x0100, 0x3aeb: 0x0100, 0x3aec: 0x0100, 0x3aed: 0x0100, 0x3aee: 0x0100, 0x3aef: 0x0100, 0x3af0: 0x0100, 0x3af1: 0x0100, 0x3af2: 0x0100, 0x3af3: 0x0008, 0x3af4: 0x0008, 0x3af5: 0x0008, 0x3af6: 0x0008, 0x3af7: 0x0008, 0x3af8: 0x0008, 0x3af9: 0x0008, 0x3afa: 0x0008, 0x3afb: 0x0008, 0x3afc: 0x0008, 0x3afd: 0x0008, 0x3afe: 0x0008, 0x3aff: 0x0008, // Block 0xec, offset 0x3b00 0x3b00: 0x0008, 0x3b01: 0x0100, 0x3b02: 0x0100, 0x3b03: 0x0100, 0x3b04: 0x0100, 0x3b05: 0x0400, 0x3b06: 0x0400, 0x3b09: 0x0008, 0x3b0a: 0x0008, 0x3b0b: 0x0008, 0x3b0c: 0x0008, 0x3b0d: 0x0400, 0x3b0e: 0x0008, 0x3b0f: 0x0008, 0x3b10: 0x0080, 0x3b11: 0x0080, 0x3b12: 0x0080, 0x3b13: 0x0080, 0x3b14: 0x0080, 0x3b15: 0x0080, 0x3b16: 0x0080, 0x3b17: 0x0080, 0x3b18: 0x0080, 0x3b19: 0x0080, 0x3b1a: 0x0100, 0x3b1c: 0x0100, 0x3b1e: 0x0400, 0x3b1f: 0x0400, // Block 0xed, offset 0x3b40 0x3b40: 0x0100, 0x3b41: 0x0100, 0x3b42: 0x0100, 0x3b43: 0x0100, 0x3b44: 0x0100, 0x3b45: 0x0100, 0x3b46: 0x0100, 0x3b47: 0x0100, 0x3b48: 0x0100, 0x3b49: 0x0100, 0x3b4a: 0x0100, 0x3b4b: 0x0100, 0x3b4c: 0x0100, 0x3b4d: 0x0100, 0x3b4e: 0x0100, 0x3b4f: 0x0100, 0x3b50: 0x0100, 0x3b51: 0x0100, 0x3b53: 0x0100, 0x3b54: 0x0100, 0x3b55: 0x0100, 0x3b56: 0x0100, 0x3b57: 0x0100, 0x3b58: 0x0100, 0x3b59: 0x0100, 0x3b5a: 0x0100, 0x3b5b: 0x0100, 0x3b5c: 0x0100, 0x3b5d: 0x0100, 0x3b5e: 0x0100, 0x3b5f: 0x0100, 0x3b60: 0x0100, 0x3b61: 0x0100, 0x3b62: 0x0100, 0x3b63: 0x0100, 0x3b64: 0x0100, 0x3b65: 0x0100, 0x3b66: 0x0100, 0x3b67: 0x0100, 0x3b68: 0x0100, 0x3b69: 0x0100, 0x3b6a: 0x0100, 0x3b6b: 0x0100, 0x3b6c: 0x0008, 0x3b6d: 0x0008, 0x3b6e: 0x0008, 0x3b6f: 0x0008, 0x3b70: 0x0008, 0x3b71: 0x0008, 0x3b72: 0x0008, 0x3b73: 0x0008, 0x3b74: 0x0008, 0x3b75: 0x0008, 0x3b76: 0x0008, 0x3b77: 0x0008, 0x3b78: 0x0400, 0x3b79: 0x0400, 0x3b7b: 0x0400, 0x3b7c: 0x0400, 0x3b7e: 0x0008, 0x3b7f: 0x0100, // Block 0xee, offset 0x3b80 0x3b80: 0x0100, 0x3b81: 0x0008, // Block 0xef, offset 0x3bc0 0x3bc0: 0x0100, 0x3bc1: 0x0100, 0x3bc2: 0x0100, 0x3bc3: 0x0100, 0x3bc4: 0x0100, 0x3bc5: 0x0100, 0x3bc6: 0x0100, 0x3bc8: 0x0100, 0x3bca: 0x0100, 0x3bcb: 0x0100, 0x3bcc: 0x0100, 0x3bcd: 0x0100, 0x3bcf: 0x0100, 0x3bd0: 0x0100, 0x3bd1: 0x0100, 0x3bd2: 0x0100, 0x3bd3: 0x0100, 0x3bd4: 0x0100, 0x3bd5: 0x0100, 0x3bd6: 0x0100, 0x3bd7: 0x0100, 0x3bd8: 0x0100, 0x3bd9: 0x0100, 0x3bda: 0x0100, 0x3bdb: 0x0100, 0x3bdc: 0x0100, 0x3bdd: 0x0100, 0x3bdf: 0x0100, 0x3be0: 0x0100, 0x3be1: 0x0100, 0x3be2: 0x0100, 0x3be3: 0x0100, 0x3be4: 0x0100, 0x3be5: 0x0100, 0x3be6: 0x0100, 0x3be7: 0x0100, 0x3be8: 0x0100, 0x3be9: 0x0400, 0x3bf0: 0x0100, 0x3bf1: 0x0100, 0x3bf2: 0x0100, 0x3bf3: 0x0100, 0x3bf4: 0x0100, 0x3bf5: 0x0100, 0x3bf6: 0x0100, 0x3bf7: 0x0100, 0x3bf8: 0x0100, 0x3bf9: 0x0100, 0x3bfa: 0x0100, 0x3bfb: 0x0100, 0x3bfc: 0x0100, 0x3bfd: 0x0100, 0x3bfe: 0x0100, 0x3bff: 0x0100, // Block 0xf0, offset 0x3c00 0x3c00: 0x0100, 0x3c01: 0x0100, 0x3c02: 0x0100, 0x3c03: 0x0100, 0x3c04: 0x0100, 0x3c05: 0x0100, 0x3c06: 0x0100, 0x3c07: 0x0100, 0x3c08: 0x0100, 0x3c09: 0x0100, 0x3c0a: 0x0100, 0x3c0b: 0x0100, 0x3c0c: 0x0100, 0x3c0d: 0x0100, 0x3c0e: 0x0100, 0x3c0f: 0x0100, 0x3c10: 0x0100, 0x3c11: 0x0100, 0x3c12: 0x0100, 0x3c13: 0x0100, 0x3c14: 0x0100, 0x3c15: 0x0100, 0x3c16: 0x0100, 0x3c17: 0x0100, 0x3c18: 0x0100, 0x3c19: 0x0100, 0x3c1a: 0x0100, 0x3c1b: 0x0100, 0x3c1c: 0x0100, 0x3c1d: 0x0100, 0x3c1e: 0x0100, 0x3c1f: 0x0008, 0x3c20: 0x0008, 0x3c21: 0x0008, 0x3c22: 0x0008, 0x3c23: 0x0008, 0x3c24: 0x0008, 0x3c25: 0x0008, 0x3c26: 0x0008, 0x3c27: 0x0008, 0x3c28: 0x0008, 0x3c29: 0x0008, 0x3c2a: 0x0008, 0x3c30: 0x0080, 0x3c31: 0x0080, 0x3c32: 0x0080, 0x3c33: 0x0080, 0x3c34: 0x0080, 0x3c35: 0x0080, 0x3c36: 0x0080, 0x3c37: 0x0080, 0x3c38: 0x0080, 0x3c39: 0x0080, // Block 0xf1, offset 0x3c40 0x3c40: 0x0008, 0x3c41: 0x0008, 0x3c42: 0x0008, 0x3c43: 0x0008, 0x3c45: 0x0100, 0x3c46: 0x0100, 0x3c47: 0x0100, 0x3c48: 0x0100, 0x3c49: 0x0100, 0x3c4a: 0x0100, 0x3c4b: 0x0100, 0x3c4c: 0x0100, 0x3c4f: 0x0100, 0x3c50: 0x0100, 0x3c53: 0x0100, 0x3c54: 0x0100, 0x3c55: 0x0100, 0x3c56: 0x0100, 0x3c57: 0x0100, 0x3c58: 0x0100, 0x3c59: 0x0100, 0x3c5a: 0x0100, 0x3c5b: 0x0100, 0x3c5c: 0x0100, 0x3c5d: 0x0100, 0x3c5e: 0x0100, 0x3c5f: 0x0100, 0x3c60: 0x0100, 0x3c61: 0x0100, 0x3c62: 0x0100, 0x3c63: 0x0100, 0x3c64: 0x0100, 0x3c65: 0x0100, 0x3c66: 0x0100, 0x3c67: 0x0100, 0x3c68: 0x0100, 0x3c6a: 0x0100, 0x3c6b: 0x0100, 0x3c6c: 0x0100, 0x3c6d: 0x0100, 0x3c6e: 0x0100, 0x3c6f: 0x0100, 0x3c70: 0x0100, 0x3c72: 0x0100, 0x3c73: 0x0100, 0x3c75: 0x0100, 0x3c76: 0x0100, 0x3c77: 0x0100, 0x3c78: 0x0100, 0x3c79: 0x0100, 0x3c7b: 0x0008, 0x3c7c: 0x0008, 0x3c7d: 0x0100, 0x3c7e: 0x0008, 0x3c7f: 0x0008, // Block 0xf2, offset 0x3c80 0x3c80: 0x0008, 0x3c81: 0x0008, 0x3c82: 0x0008, 0x3c83: 0x0008, 0x3c84: 0x0008, 0x3c87: 0x0008, 0x3c88: 0x0008, 0x3c8b: 0x0008, 0x3c8c: 0x0008, 0x3c8d: 0x0008, 0x3c90: 0x0100, 0x3c97: 0x0008, 0x3c9d: 0x0100, 0x3c9e: 0x0100, 0x3c9f: 0x0100, 0x3ca0: 0x0100, 0x3ca1: 0x0100, 0x3ca2: 0x0008, 0x3ca3: 0x0008, 0x3ca6: 0x0008, 0x3ca7: 0x0008, 0x3ca8: 0x0008, 0x3ca9: 0x0008, 0x3caa: 0x0008, 0x3cab: 0x0008, 0x3cac: 0x0008, 0x3cb0: 0x0008, 0x3cb1: 0x0008, 0x3cb2: 0x0008, 0x3cb3: 0x0008, 0x3cb4: 0x0008, // Block 0xf3, offset 0x3cc0 0x3cc0: 0x0100, 0x3cc1: 0x0100, 0x3cc2: 0x0100, 0x3cc3: 0x0100, 0x3cc4: 0x0100, 0x3cc5: 0x0100, 0x3cc6: 0x0100, 0x3cc7: 0x0100, 0x3cc8: 0x0100, 0x3cc9: 0x0100, 0x3ccb: 0x0100, 0x3cce: 0x0100, 0x3cd0: 0x0100, 0x3cd1: 0x0100, 0x3cd2: 0x0100, 0x3cd3: 0x0100, 0x3cd4: 0x0100, 0x3cd5: 0x0100, 0x3cd6: 0x0100, 0x3cd7: 0x0100, 0x3cd8: 0x0100, 0x3cd9: 0x0100, 0x3cda: 0x0100, 0x3cdb: 0x0100, 0x3cdc: 0x0100, 0x3cdd: 0x0100, 0x3cde: 0x0100, 0x3cdf: 0x0100, 0x3ce0: 0x0100, 0x3ce1: 0x0100, 0x3ce2: 0x0100, 0x3ce3: 0x0100, 0x3ce4: 0x0100, 0x3ce5: 0x0100, 0x3ce6: 0x0100, 0x3ce7: 0x0100, 0x3ce8: 0x0100, 0x3ce9: 0x0100, 0x3cea: 0x0100, 0x3ceb: 0x0100, 0x3cec: 0x0100, 0x3ced: 0x0100, 0x3cee: 0x0100, 0x3cef: 0x0100, 0x3cf0: 0x0100, 0x3cf1: 0x0100, 0x3cf2: 0x0100, 0x3cf3: 0x0100, 0x3cf4: 0x0100, 0x3cf5: 0x0100, 0x3cf7: 0x0100, 0x3cf8: 0x0008, 0x3cf9: 0x0008, 0x3cfa: 0x0008, 0x3cfb: 0x0008, 0x3cfc: 0x0008, 0x3cfd: 0x0008, 0x3cfe: 0x0008, 0x3cff: 0x0008, // Block 0xf4, offset 0x3d00 0x3d00: 0x0008, 0x3d02: 0x0008, 0x3d05: 0x0008, 0x3d07: 0x0008, 0x3d08: 0x0008, 0x3d09: 0x0008, 0x3d0a: 0x0008, 0x3d0c: 0x0008, 0x3d0d: 0x0008, 0x3d0e: 0x0008, 0x3d0f: 0x0008, 0x3d10: 0x0008, 0x3d11: 0x0100, 0x3d12: 0x0008, 0x3d13: 0x0100, 0x3d14: 0x0400, 0x3d15: 0x0400, 0x3d21: 0x0008, 0x3d22: 0x0008, // Block 0xf5, offset 0x3d40 0x3d40: 0x0100, 0x3d41: 0x0100, 0x3d42: 0x0100, 0x3d43: 0x0100, 0x3d44: 0x0100, 0x3d45: 0x0100, 0x3d46: 0x0100, 0x3d47: 0x0100, 0x3d48: 0x0100, 0x3d49: 0x0100, 0x3d4a: 0x0100, 0x3d4b: 0x0100, 0x3d4c: 0x0100, 0x3d4d: 0x0100, 0x3d4e: 0x0100, 0x3d4f: 0x0100, 0x3d50: 0x0100, 0x3d51: 0x0100, 0x3d52: 0x0100, 0x3d53: 0x0100, 0x3d54: 0x0100, 0x3d55: 0x0100, 0x3d56: 0x0100, 0x3d57: 0x0100, 0x3d58: 0x0100, 0x3d59: 0x0100, 0x3d5a: 0x0100, 0x3d5b: 0x0100, 0x3d5c: 0x0100, 0x3d5d: 0x0100, 0x3d5e: 0x0100, 0x3d5f: 0x0100, 0x3d60: 0x0100, 0x3d61: 0x0100, 0x3d62: 0x0100, 0x3d63: 0x0100, 0x3d64: 0x0100, 0x3d65: 0x0100, 0x3d66: 0x0100, 0x3d67: 0x0100, 0x3d68: 0x0100, 0x3d69: 0x0100, 0x3d6a: 0x0100, 0x3d6b: 0x0100, 0x3d6c: 0x0100, 0x3d6d: 0x0100, 0x3d6e: 0x0100, 0x3d6f: 0x0100, 0x3d70: 0x0100, 0x3d71: 0x0100, 0x3d72: 0x0100, 0x3d73: 0x0100, 0x3d74: 0x0100, 0x3d75: 0x0008, 0x3d76: 0x0008, 0x3d77: 0x0008, 0x3d78: 0x0008, 0x3d79: 0x0008, 0x3d7a: 0x0008, 0x3d7b: 0x0008, 0x3d7c: 0x0008, 0x3d7d: 0x0008, 0x3d7e: 0x0008, 0x3d7f: 0x0008, // Block 0xf6, offset 0x3d80 0x3d80: 0x0008, 0x3d81: 0x0008, 0x3d82: 0x0008, 0x3d83: 0x0008, 0x3d84: 0x0008, 0x3d85: 0x0008, 0x3d86: 0x0008, 0x3d87: 0x0100, 0x3d88: 0x0100, 0x3d89: 0x0100, 0x3d8a: 0x0100, 0x3d8b: 0x0400, 0x3d8c: 0x0400, 0x3d90: 0x0080, 0x3d91: 0x0080, 0x3d92: 0x0080, 0x3d93: 0x0080, 0x3d94: 0x0080, 0x3d95: 0x0080, 0x3d96: 0x0080, 0x3d97: 0x0080, 0x3d98: 0x0080, 0x3d99: 0x0080, 0x3d9e: 0x0008, 0x3d9f: 0x0100, 0x3da0: 0x0100, 0x3da1: 0x0100, // Block 0xf7, offset 0x3dc0 0x3dc0: 0x0100, 0x3dc1: 0x0100, 0x3dc2: 0x0100, 0x3dc3: 0x0100, 0x3dc4: 0x0100, 0x3dc5: 0x0100, 0x3dc6: 0x0100, 0x3dc7: 0x0100, 0x3dc8: 0x0100, 0x3dc9: 0x0100, 0x3dca: 0x0100, 0x3dcb: 0x0100, 0x3dcc: 0x0100, 0x3dcd: 0x0100, 0x3dce: 0x0100, 0x3dcf: 0x0100, 0x3dd0: 0x0100, 0x3dd1: 0x0100, 0x3dd2: 0x0100, 0x3dd3: 0x0100, 0x3dd4: 0x0100, 0x3dd5: 0x0100, 0x3dd6: 0x0100, 0x3dd7: 0x0100, 0x3dd8: 0x0100, 0x3dd9: 0x0100, 0x3dda: 0x0100, 0x3ddb: 0x0100, 0x3ddc: 0x0100, 0x3ddd: 0x0100, 0x3dde: 0x0100, 0x3ddf: 0x0100, 0x3de0: 0x0100, 0x3de1: 0x0100, 0x3de2: 0x0100, 0x3de3: 0x0100, 0x3de4: 0x0100, 0x3de5: 0x0100, 0x3de6: 0x0100, 0x3de7: 0x0100, 0x3de8: 0x0100, 0x3de9: 0x0100, 0x3dea: 0x0100, 0x3deb: 0x0100, 0x3dec: 0x0100, 0x3ded: 0x0100, 0x3dee: 0x0100, 0x3def: 0x0100, 0x3df0: 0x0008, 0x3df1: 0x0008, 0x3df2: 0x0008, 0x3df3: 0x0008, 0x3df4: 0x0008, 0x3df5: 0x0008, 0x3df6: 0x0008, 0x3df7: 0x0008, 0x3df8: 0x0008, 0x3df9: 0x0008, 0x3dfa: 0x0008, 0x3dfb: 0x0008, 0x3dfc: 0x0008, 0x3dfd: 0x0008, 0x3dfe: 0x0008, 0x3dff: 0x0008, // Block 0xf8, offset 0x3e00 0x3e00: 0x0008, 0x3e01: 0x0008, 0x3e02: 0x0008, 0x3e03: 0x0008, 0x3e04: 0x0100, 0x3e05: 0x0100, 0x3e07: 0x0100, 0x3e10: 0x0080, 0x3e11: 0x0080, 0x3e12: 0x0080, 0x3e13: 0x0080, 0x3e14: 0x0080, 0x3e15: 0x0080, 0x3e16: 0x0080, 0x3e17: 0x0080, 0x3e18: 0x0080, 0x3e19: 0x0080, // Block 0xf9, offset 0x3e40 0x3e40: 0x0100, 0x3e41: 0x0100, 0x3e42: 0x0100, 0x3e43: 0x0100, 0x3e44: 0x0100, 0x3e45: 0x0100, 0x3e46: 0x0100, 0x3e47: 0x0100, 0x3e48: 0x0100, 0x3e49: 0x0100, 0x3e4a: 0x0100, 0x3e4b: 0x0100, 0x3e4c: 0x0100, 0x3e4d: 0x0100, 0x3e4e: 0x0100, 0x3e4f: 0x0100, 0x3e50: 0x0100, 0x3e51: 0x0100, 0x3e52: 0x0100, 0x3e53: 0x0100, 0x3e54: 0x0100, 0x3e55: 0x0100, 0x3e56: 0x0100, 0x3e57: 0x0100, 0x3e58: 0x0100, 0x3e59: 0x0100, 0x3e5a: 0x0100, 0x3e5b: 0x0100, 0x3e5c: 0x0100, 0x3e5d: 0x0100, 0x3e5e: 0x0100, 0x3e5f: 0x0100, 0x3e60: 0x0100, 0x3e61: 0x0100, 0x3e62: 0x0100, 0x3e63: 0x0100, 0x3e64: 0x0100, 0x3e65: 0x0100, 0x3e66: 0x0100, 0x3e67: 0x0100, 0x3e68: 0x0100, 0x3e69: 0x0100, 0x3e6a: 0x0100, 0x3e6b: 0x0100, 0x3e6c: 0x0100, 0x3e6d: 0x0100, 0x3e6e: 0x0100, 0x3e6f: 0x0008, 0x3e70: 0x0008, 0x3e71: 0x0008, 0x3e72: 0x0008, 0x3e73: 0x0008, 0x3e74: 0x0008, 0x3e75: 0x0008, 0x3e78: 0x0008, 0x3e79: 0x0008, 0x3e7a: 0x0008, 0x3e7b: 0x0008, 0x3e7c: 0x0008, 0x3e7d: 0x0008, 0x3e7e: 0x0008, 0x3e7f: 0x0008, // Block 0xfa, offset 0x3e80 0x3e80: 0x0008, 0x3e82: 0x0400, 0x3e83: 0x0400, 0x3e89: 0x0400, 0x3e8a: 0x0400, 0x3e8b: 0x0400, 0x3e8c: 0x0400, 0x3e8d: 0x0400, 0x3e8e: 0x0400, 0x3e8f: 0x0400, 0x3e90: 0x0400, 0x3e91: 0x0400, 0x3e92: 0x0400, 0x3e93: 0x0400, 0x3e94: 0x0400, 0x3e95: 0x0400, 0x3e96: 0x0400, 0x3e97: 0x0400, 0x3e98: 0x0100, 0x3e99: 0x0100, 0x3e9a: 0x0100, 0x3e9b: 0x0100, 0x3e9c: 0x0008, 0x3e9d: 0x0008, // Block 0xfb, offset 0x3ec0 0x3ec0: 0x0008, 0x3ec1: 0x0400, 0x3ec2: 0x0400, 0x3ec4: 0x0100, 0x3ed0: 0x0080, 0x3ed1: 0x0080, 0x3ed2: 0x0080, 0x3ed3: 0x0080, 0x3ed4: 0x0080, 0x3ed5: 0x0080, 0x3ed6: 0x0080, 0x3ed7: 0x0080, 0x3ed8: 0x0080, 0x3ed9: 0x0080, // Block 0xfc, offset 0x3f00 0x3f00: 0x0100, 0x3f01: 0x0100, 0x3f02: 0x0100, 0x3f03: 0x0100, 0x3f04: 0x0100, 0x3f05: 0x0100, 0x3f06: 0x0100, 0x3f07: 0x0100, 0x3f08: 0x0100, 0x3f09: 0x0100, 0x3f0a: 0x0100, 0x3f0b: 0x0100, 0x3f0c: 0x0100, 0x3f0d: 0x0100, 0x3f0e: 0x0100, 0x3f0f: 0x0100, 0x3f10: 0x0100, 0x3f11: 0x0100, 0x3f12: 0x0100, 0x3f13: 0x0100, 0x3f14: 0x0100, 0x3f15: 0x0100, 0x3f16: 0x0100, 0x3f17: 0x0100, 0x3f18: 0x0100, 0x3f19: 0x0100, 0x3f1a: 0x0100, 0x3f1b: 0x0100, 0x3f1c: 0x0100, 0x3f1d: 0x0100, 0x3f1e: 0x0100, 0x3f1f: 0x0100, 0x3f20: 0x0100, 0x3f21: 0x0100, 0x3f22: 0x0100, 0x3f23: 0x0100, 0x3f24: 0x0100, 0x3f25: 0x0100, 0x3f26: 0x0100, 0x3f27: 0x0100, 0x3f28: 0x0100, 0x3f29: 0x0100, 0x3f2a: 0x0100, 0x3f2b: 0x0008, 0x3f2c: 0x0008, 0x3f2d: 0x0008, 0x3f2e: 0x0008, 0x3f2f: 0x0008, 0x3f30: 0x0008, 0x3f31: 0x0008, 0x3f32: 0x0008, 0x3f33: 0x0008, 0x3f34: 0x0008, 0x3f35: 0x0008, 0x3f36: 0x0008, 0x3f37: 0x0008, 0x3f38: 0x0100, // Block 0xfd, offset 0x3f40 0x3f40: 0x0080, 0x3f41: 0x0080, 0x3f42: 0x0080, 0x3f43: 0x0080, 0x3f44: 0x0080, 0x3f45: 0x0080, 0x3f46: 0x0080, 0x3f47: 0x0080, 0x3f48: 0x0080, 0x3f49: 0x0080, 0x3f50: 0x0080, 0x3f51: 0x0080, 0x3f52: 0x0080, 0x3f53: 0x0080, 0x3f54: 0x0080, 0x3f55: 0x0080, 0x3f56: 0x0080, 0x3f57: 0x0080, 0x3f58: 0x0080, 0x3f59: 0x0080, 0x3f5a: 0x0080, 0x3f5b: 0x0080, 0x3f5c: 0x0080, 0x3f5d: 0x0080, 0x3f5e: 0x0080, 0x3f5f: 0x0080, 0x3f60: 0x0080, 0x3f61: 0x0080, 0x3f62: 0x0080, 0x3f63: 0x0080, // Block 0xfe, offset 0x3f80 0x3f80: 0x0100, 0x3f81: 0x0100, 0x3f82: 0x0100, 0x3f83: 0x0100, 0x3f84: 0x0100, 0x3f85: 0x0100, 0x3f86: 0x0100, 0x3f87: 0x0100, 0x3f88: 0x0100, 0x3f89: 0x0100, 0x3f8a: 0x0100, 0x3f8b: 0x0100, 0x3f8c: 0x0100, 0x3f8d: 0x0100, 0x3f8e: 0x0100, 0x3f8f: 0x0100, 0x3f90: 0x0100, 0x3f91: 0x0100, 0x3f92: 0x0100, 0x3f93: 0x0100, 0x3f94: 0x0100, 0x3f95: 0x0100, 0x3f96: 0x0100, 0x3f97: 0x0100, 0x3f98: 0x0100, 0x3f99: 0x0100, 0x3f9a: 0x0100, 0x3f9d: 0x0008, 0x3f9e: 0x0008, 0x3f9f: 0x0008, 0x3fa0: 0x0008, 0x3fa1: 0x0008, 0x3fa2: 0x0008, 0x3fa3: 0x0008, 0x3fa4: 0x0008, 0x3fa5: 0x0008, 0x3fa6: 0x0008, 0x3fa7: 0x0008, 0x3fa8: 0x0008, 0x3fa9: 0x0008, 0x3faa: 0x0008, 0x3fab: 0x0008, 0x3fb0: 0x0080, 0x3fb1: 0x0080, 0x3fb2: 0x0080, 0x3fb3: 0x0080, 0x3fb4: 0x0080, 0x3fb5: 0x0080, 0x3fb6: 0x0080, 0x3fb7: 0x0080, 0x3fb8: 0x0080, 0x3fb9: 0x0080, 0x3fbc: 0x0400, 0x3fbd: 0x0400, 0x3fbe: 0x0400, // Block 0xff, offset 0x3fc0 0x3fc0: 0x0100, 0x3fc1: 0x0100, 0x3fc2: 0x0100, 0x3fc3: 0x0100, 0x3fc4: 0x0100, 0x3fc5: 0x0100, 0x3fc6: 0x0100, // Block 0x100, offset 0x4000 0x4000: 0x0100, 0x4001: 0x0100, 0x4002: 0x0100, 0x4003: 0x0100, 0x4004: 0x0100, 0x4005: 0x0100, 0x4006: 0x0100, 0x4007: 0x0100, 0x4008: 0x0100, 0x4009: 0x0100, 0x400a: 0x0100, 0x400b: 0x0100, 0x400c: 0x0100, 0x400d: 0x0100, 0x400e: 0x0100, 0x400f: 0x0100, 0x4010: 0x0100, 0x4011: 0x0100, 0x4012: 0x0100, 0x4013: 0x0100, 0x4014: 0x0100, 0x4015: 0x0100, 0x4016: 0x0100, 0x4017: 0x0100, 0x4018: 0x0100, 0x4019: 0x0100, 0x401a: 0x0100, 0x401b: 0x0100, 0x401c: 0x0100, 0x401d: 0x0100, 0x401e: 0x0100, 0x401f: 0x0100, 0x4020: 0x0100, 0x4021: 0x0100, 0x4022: 0x0100, 0x4023: 0x0100, 0x4024: 0x0100, 0x4025: 0x0100, 0x4026: 0x0100, 0x4027: 0x0100, 0x4028: 0x0100, 0x4029: 0x0100, 0x402a: 0x0100, 0x402b: 0x0100, 0x402c: 0x0008, 0x402d: 0x0008, 0x402e: 0x0008, 0x402f: 0x0008, 0x4030: 0x0008, 0x4031: 0x0008, 0x4032: 0x0008, 0x4033: 0x0008, 0x4034: 0x0008, 0x4035: 0x0008, 0x4036: 0x0008, 0x4037: 0x0008, 0x4038: 0x0008, 0x4039: 0x0008, 0x403a: 0x0008, // Block 0x101, offset 0x4040 0x4060: 0x2000, 0x4061: 0x2000, 0x4062: 0x2000, 0x4063: 0x2000, 0x4064: 0x2000, 0x4065: 0x2000, 0x4066: 0x2000, 0x4067: 0x2000, 0x4068: 0x2000, 0x4069: 0x2000, 0x406a: 0x2000, 0x406b: 0x2000, 0x406c: 0x2000, 0x406d: 0x2000, 0x406e: 0x2000, 0x406f: 0x2000, 0x4070: 0x2000, 0x4071: 0x2000, 0x4072: 0x2000, 0x4073: 0x2000, 0x4074: 0x2000, 0x4075: 0x2000, 0x4076: 0x2000, 0x4077: 0x2000, 0x4078: 0x2000, 0x4079: 0x2000, 0x407a: 0x2000, 0x407b: 0x2000, 0x407c: 0x2000, 0x407d: 0x2000, 0x407e: 0x2000, 0x407f: 0x2000, // Block 0x102, offset 0x4080 0x4080: 0x0040, 0x4081: 0x0040, 0x4082: 0x0040, 0x4083: 0x0040, 0x4084: 0x0040, 0x4085: 0x0040, 0x4086: 0x0040, 0x4087: 0x0040, 0x4088: 0x0040, 0x4089: 0x0040, 0x408a: 0x0040, 0x408b: 0x0040, 0x408c: 0x0040, 0x408d: 0x0040, 0x408e: 0x0040, 0x408f: 0x0040, 0x4090: 0x0040, 0x4091: 0x0040, 0x4092: 0x0040, 0x4093: 0x0040, 0x4094: 0x0040, 0x4095: 0x0040, 0x4096: 0x0040, 0x4097: 0x0040, 0x4098: 0x0040, 0x4099: 0x0040, 0x409a: 0x0040, 0x409b: 0x0040, 0x409c: 0x0040, 0x409d: 0x0040, 0x409e: 0x0040, 0x409f: 0x0040, 0x40a0: 0x0080, 0x40a1: 0x0080, 0x40a2: 0x0080, 0x40a3: 0x0080, 0x40a4: 0x0080, 0x40a5: 0x0080, 0x40a6: 0x0080, 0x40a7: 0x0080, 0x40a8: 0x0080, 0x40a9: 0x0080, 0x40bf: 0x0100, // Block 0x103, offset 0x40c0 0x40c0: 0x0100, 0x40c1: 0x0100, 0x40c2: 0x0100, 0x40c3: 0x0100, 0x40c4: 0x0100, 0x40c5: 0x0100, 0x40c6: 0x0100, 0x40c9: 0x0100, 0x40cc: 0x0100, 0x40cd: 0x0100, 0x40ce: 0x0100, 0x40cf: 0x0100, 0x40d0: 0x0100, 0x40d1: 0x0100, 0x40d2: 0x0100, 0x40d3: 0x0100, 0x40d5: 0x0100, 0x40d6: 0x0100, 0x40d8: 0x0100, 0x40d9: 0x0100, 0x40da: 0x0100, 0x40db: 0x0100, 0x40dc: 0x0100, 0x40dd: 0x0100, 0x40de: 0x0100, 0x40df: 0x0100, 0x40e0: 0x0100, 0x40e1: 0x0100, 0x40e2: 0x0100, 0x40e3: 0x0100, 0x40e4: 0x0100, 0x40e5: 0x0100, 0x40e6: 0x0100, 0x40e7: 0x0100, 0x40e8: 0x0100, 0x40e9: 0x0100, 0x40ea: 0x0100, 0x40eb: 0x0100, 0x40ec: 0x0100, 0x40ed: 0x0100, 0x40ee: 0x0100, 0x40ef: 0x0100, 0x40f0: 0x0008, 0x40f1: 0x0008, 0x40f2: 0x0008, 0x40f3: 0x0008, 0x40f4: 0x0008, 0x40f5: 0x0008, 0x40f7: 0x0008, 0x40f8: 0x0008, 0x40fb: 0x0008, 0x40fc: 0x0008, 0x40fd: 0x0008, 0x40fe: 0x0008, 0x40ff: 0x0100, // Block 0x104, offset 0x4100 0x4100: 0x0008, 0x4101: 0x0100, 0x4102: 0x0008, 0x4103: 0x0008, 0x4104: 0x0400, 0x4106: 0x0400, 0x4110: 0x0080, 0x4111: 0x0080, 0x4112: 0x0080, 0x4113: 0x0080, 0x4114: 0x0080, 0x4115: 0x0080, 0x4116: 0x0080, 0x4117: 0x0080, 0x4118: 0x0080, 0x4119: 0x0080, // Block 0x105, offset 0x4140 0x4160: 0x0100, 0x4161: 0x0100, 0x4162: 0x0100, 0x4163: 0x0100, 0x4164: 0x0100, 0x4165: 0x0100, 0x4166: 0x0100, 0x4167: 0x0100, 0x416a: 0x0100, 0x416b: 0x0100, 0x416c: 0x0100, 0x416d: 0x0100, 0x416e: 0x0100, 0x416f: 0x0100, 0x4170: 0x0100, 0x4171: 0x0100, 0x4172: 0x0100, 0x4173: 0x0100, 0x4174: 0x0100, 0x4175: 0x0100, 0x4176: 0x0100, 0x4177: 0x0100, 0x4178: 0x0100, 0x4179: 0x0100, 0x417a: 0x0100, 0x417b: 0x0100, 0x417c: 0x0100, 0x417d: 0x0100, 0x417e: 0x0100, 0x417f: 0x0100, // Block 0x106, offset 0x4180 0x4180: 0x0100, 0x4181: 0x0100, 0x4182: 0x0100, 0x4183: 0x0100, 0x4184: 0x0100, 0x4185: 0x0100, 0x4186: 0x0100, 0x4187: 0x0100, 0x4188: 0x0100, 0x4189: 0x0100, 0x418a: 0x0100, 0x418b: 0x0100, 0x418c: 0x0100, 0x418d: 0x0100, 0x418e: 0x0100, 0x418f: 0x0100, 0x4190: 0x0100, 0x4191: 0x0008, 0x4192: 0x0008, 0x4193: 0x0008, 0x4194: 0x0008, 0x4195: 0x0008, 0x4196: 0x0008, 0x4197: 0x0008, 0x419a: 0x0008, 0x419b: 0x0008, 0x419c: 0x0008, 0x419d: 0x0008, 0x419e: 0x0008, 0x419f: 0x0008, 0x41a0: 0x0008, 0x41a1: 0x0100, 0x41a3: 0x0100, 0x41a4: 0x0008, // Block 0x107, offset 0x41c0 0x41c0: 0x0100, 0x41c1: 0x0008, 0x41c2: 0x0008, 0x41c3: 0x0008, 0x41c4: 0x0008, 0x41c5: 0x0008, 0x41c6: 0x0008, 0x41c7: 0x0008, 0x41c8: 0x0008, 0x41c9: 0x0008, 0x41ca: 0x0008, 0x41cb: 0x0100, 0x41cc: 0x0100, 0x41cd: 0x0100, 0x41ce: 0x0100, 0x41cf: 0x0100, 0x41d0: 0x0100, 0x41d1: 0x0100, 0x41d2: 0x0100, 0x41d3: 0x0100, 0x41d4: 0x0100, 0x41d5: 0x0100, 0x41d6: 0x0100, 0x41d7: 0x0100, 0x41d8: 0x0100, 0x41d9: 0x0100, 0x41da: 0x0100, 0x41db: 0x0100, 0x41dc: 0x0100, 0x41dd: 0x0100, 0x41de: 0x0100, 0x41df: 0x0100, 0x41e0: 0x0100, 0x41e1: 0x0100, 0x41e2: 0x0100, 0x41e3: 0x0100, 0x41e4: 0x0100, 0x41e5: 0x0100, 0x41e6: 0x0100, 0x41e7: 0x0100, 0x41e8: 0x0100, 0x41e9: 0x0100, 0x41ea: 0x0100, 0x41eb: 0x0100, 0x41ec: 0x0100, 0x41ed: 0x0100, 0x41ee: 0x0100, 0x41ef: 0x0100, 0x41f0: 0x0100, 0x41f1: 0x0100, 0x41f2: 0x0100, 0x41f3: 0x0008, 0x41f4: 0x0008, 0x41f5: 0x0008, 0x41f6: 0x0008, 0x41f7: 0x0008, 0x41f8: 0x0008, 0x41f9: 0x0008, 0x41fa: 0x0100, 0x41fb: 0x0008, 0x41fc: 0x0008, 0x41fd: 0x0008, 0x41fe: 0x0008, // Block 0x108, offset 0x4200 0x4202: 0x0400, 0x4203: 0x0400, 0x4207: 0x0008, 0x4210: 0x0100, 0x4211: 0x0008, 0x4212: 0x0008, 0x4213: 0x0008, 0x4214: 0x0008, 0x4215: 0x0008, 0x4216: 0x0008, 0x4217: 0x0008, 0x4218: 0x0008, 0x4219: 0x0008, 0x421a: 0x0008, 0x421b: 0x0008, 0x421c: 0x0100, 0x421d: 0x0100, 0x421e: 0x0100, 0x421f: 0x0100, 0x4220: 0x0100, 0x4221: 0x0100, 0x4222: 0x0100, 0x4223: 0x0100, 0x4224: 0x0100, 0x4225: 0x0100, 0x4226: 0x0100, 0x4227: 0x0100, 0x4228: 0x0100, 0x4229: 0x0100, 0x422a: 0x0100, 0x422b: 0x0100, 0x422c: 0x0100, 0x422d: 0x0100, 0x422e: 0x0100, 0x422f: 0x0100, 0x4230: 0x0100, 0x4231: 0x0100, 0x4232: 0x0100, 0x4233: 0x0100, 0x4234: 0x0100, 0x4235: 0x0100, 0x4236: 0x0100, 0x4237: 0x0100, 0x4238: 0x0100, 0x4239: 0x0100, 0x423a: 0x0100, 0x423b: 0x0100, 0x423c: 0x0100, 0x423d: 0x0100, 0x423e: 0x0100, 0x423f: 0x0100, // Block 0x109, offset 0x4240 0x4240: 0x0100, 0x4241: 0x0100, 0x4242: 0x0100, 0x4243: 0x0100, 0x4244: 0x0100, 0x4245: 0x0100, 0x4246: 0x0100, 0x4247: 0x0100, 0x4248: 0x0100, 0x4249: 0x0100, 0x424a: 0x0008, 0x424b: 0x0008, 0x424c: 0x0008, 0x424d: 0x0008, 0x424e: 0x0008, 0x424f: 0x0008, 0x4250: 0x0008, 0x4251: 0x0008, 0x4252: 0x0008, 0x4253: 0x0008, 0x4254: 0x0008, 0x4255: 0x0008, 0x4256: 0x0008, 0x4257: 0x0008, 0x4258: 0x0008, 0x4259: 0x0008, 0x425b: 0x0400, 0x425c: 0x0400, 0x425d: 0x0100, 0x4270: 0x0100, 0x4271: 0x0100, 0x4272: 0x0100, 0x4273: 0x0100, 0x4274: 0x0100, 0x4275: 0x0100, 0x4276: 0x0100, 0x4277: 0x0100, 0x4278: 0x0100, 0x4279: 0x0100, 0x427a: 0x0100, 0x427b: 0x0100, 0x427c: 0x0100, 0x427d: 0x0100, 0x427e: 0x0100, 0x427f: 0x0100, // Block 0x10a, offset 0x4280 0x42a0: 0x0008, 0x42a1: 0x0008, 0x42a2: 0x0008, 0x42a3: 0x0008, 0x42a4: 0x0008, 0x42a5: 0x0008, 0x42a6: 0x0008, 0x42a7: 0x0008, // Block 0x10b, offset 0x42c0 0x42c0: 0x0100, 0x42c1: 0x0100, 0x42c2: 0x0100, 0x42c3: 0x0100, 0x42c4: 0x0100, 0x42c5: 0x0100, 0x42c6: 0x0100, 0x42c7: 0x0100, 0x42c8: 0x0100, 0x42c9: 0x0100, 0x42ca: 0x0100, 0x42cb: 0x0100, 0x42cc: 0x0100, 0x42cd: 0x0100, 0x42ce: 0x0100, 0x42cf: 0x0100, 0x42d0: 0x0100, 0x42d1: 0x0100, 0x42d2: 0x0100, 0x42d3: 0x0100, 0x42d4: 0x0100, 0x42d5: 0x0100, 0x42d6: 0x0100, 0x42d7: 0x0100, 0x42d8: 0x0100, 0x42d9: 0x0100, 0x42da: 0x0100, 0x42db: 0x0100, 0x42dc: 0x0100, 0x42dd: 0x0100, 0x42de: 0x0100, 0x42df: 0x0100, 0x42e0: 0x0100, 0x42f0: 0x0080, 0x42f1: 0x0080, 0x42f2: 0x0080, 0x42f3: 0x0080, 0x42f4: 0x0080, 0x42f5: 0x0080, 0x42f6: 0x0080, 0x42f7: 0x0080, 0x42f8: 0x0080, 0x42f9: 0x0080, // Block 0x10c, offset 0x4300 0x4300: 0x0100, 0x4301: 0x0100, 0x4302: 0x0100, 0x4303: 0x0100, 0x4304: 0x0100, 0x4305: 0x0100, 0x4306: 0x0100, 0x4307: 0x0100, 0x4308: 0x0100, 0x430a: 0x0100, 0x430b: 0x0100, 0x430c: 0x0100, 0x430d: 0x0100, 0x430e: 0x0100, 0x430f: 0x0100, 0x4310: 0x0100, 0x4311: 0x0100, 0x4312: 0x0100, 0x4313: 0x0100, 0x4314: 0x0100, 0x4315: 0x0100, 0x4316: 0x0100, 0x4317: 0x0100, 0x4318: 0x0100, 0x4319: 0x0100, 0x431a: 0x0100, 0x431b: 0x0100, 0x431c: 0x0100, 0x431d: 0x0100, 0x431e: 0x0100, 0x431f: 0x0100, 0x4320: 0x0100, 0x4321: 0x0100, 0x4322: 0x0100, 0x4323: 0x0100, 0x4324: 0x0100, 0x4325: 0x0100, 0x4326: 0x0100, 0x4327: 0x0100, 0x4328: 0x0100, 0x4329: 0x0100, 0x432a: 0x0100, 0x432b: 0x0100, 0x432c: 0x0100, 0x432d: 0x0100, 0x432e: 0x0100, 0x432f: 0x0008, 0x4330: 0x0008, 0x4331: 0x0008, 0x4332: 0x0008, 0x4333: 0x0008, 0x4334: 0x0008, 0x4335: 0x0008, 0x4336: 0x0008, 0x4338: 0x0008, 0x4339: 0x0008, 0x433a: 0x0008, 0x433b: 0x0008, 0x433c: 0x0008, 0x433d: 0x0008, 0x433e: 0x0008, 0x433f: 0x0008, // Block 0x10d, offset 0x4340 0x4340: 0x0100, 0x4341: 0x0400, 0x4342: 0x0400, 0x4350: 0x0080, 0x4351: 0x0080, 0x4352: 0x0080, 0x4353: 0x0080, 0x4354: 0x0080, 0x4355: 0x0080, 0x4356: 0x0080, 0x4357: 0x0080, 0x4358: 0x0080, 0x4359: 0x0080, 0x4372: 0x0100, 0x4373: 0x0100, 0x4374: 0x0100, 0x4375: 0x0100, 0x4376: 0x0100, 0x4377: 0x0100, 0x4378: 0x0100, 0x4379: 0x0100, 0x437a: 0x0100, 0x437b: 0x0100, 0x437c: 0x0100, 0x437d: 0x0100, 0x437e: 0x0100, 0x437f: 0x0100, // Block 0x10e, offset 0x4380 0x4380: 0x0100, 0x4381: 0x0100, 0x4382: 0x0100, 0x4383: 0x0100, 0x4384: 0x0100, 0x4385: 0x0100, 0x4386: 0x0100, 0x4387: 0x0100, 0x4388: 0x0100, 0x4389: 0x0100, 0x438a: 0x0100, 0x438b: 0x0100, 0x438c: 0x0100, 0x438d: 0x0100, 0x438e: 0x0100, 0x438f: 0x0100, 0x4392: 0x0008, 0x4393: 0x0008, 0x4394: 0x0008, 0x4395: 0x0008, 0x4396: 0x0008, 0x4397: 0x0008, 0x4398: 0x0008, 0x4399: 0x0008, 0x439a: 0x0008, 0x439b: 0x0008, 0x439c: 0x0008, 0x439d: 0x0008, 0x439e: 0x0008, 0x439f: 0x0008, 0x43a0: 0x0008, 0x43a1: 0x0008, 0x43a2: 0x0008, 0x43a3: 0x0008, 0x43a4: 0x0008, 0x43a5: 0x0008, 0x43a6: 0x0008, 0x43a7: 0x0008, 0x43a9: 0x0008, 0x43aa: 0x0008, 0x43ab: 0x0008, 0x43ac: 0x0008, 0x43ad: 0x0008, 0x43ae: 0x0008, 0x43af: 0x0008, 0x43b0: 0x0008, 0x43b1: 0x0008, 0x43b2: 0x0008, 0x43b3: 0x0008, 0x43b4: 0x0008, 0x43b5: 0x0008, 0x43b6: 0x0008, // Block 0x10f, offset 0x43c0 0x43c0: 0x0100, 0x43c1: 0x0100, 0x43c2: 0x0100, 0x43c3: 0x0100, 0x43c4: 0x0100, 0x43c5: 0x0100, 0x43c6: 0x0100, 0x43c8: 0x0100, 0x43c9: 0x0100, 0x43cb: 0x0100, 0x43cc: 0x0100, 0x43cd: 0x0100, 0x43ce: 0x0100, 0x43cf: 0x0100, 0x43d0: 0x0100, 0x43d1: 0x0100, 0x43d2: 0x0100, 0x43d3: 0x0100, 0x43d4: 0x0100, 0x43d5: 0x0100, 0x43d6: 0x0100, 0x43d7: 0x0100, 0x43d8: 0x0100, 0x43d9: 0x0100, 0x43da: 0x0100, 0x43db: 0x0100, 0x43dc: 0x0100, 0x43dd: 0x0100, 0x43de: 0x0100, 0x43df: 0x0100, 0x43e0: 0x0100, 0x43e1: 0x0100, 0x43e2: 0x0100, 0x43e3: 0x0100, 0x43e4: 0x0100, 0x43e5: 0x0100, 0x43e6: 0x0100, 0x43e7: 0x0100, 0x43e8: 0x0100, 0x43e9: 0x0100, 0x43ea: 0x0100, 0x43eb: 0x0100, 0x43ec: 0x0100, 0x43ed: 0x0100, 0x43ee: 0x0100, 0x43ef: 0x0100, 0x43f0: 0x0100, 0x43f1: 0x0008, 0x43f2: 0x0008, 0x43f3: 0x0008, 0x43f4: 0x0008, 0x43f5: 0x0008, 0x43f6: 0x0008, 0x43fa: 0x0008, 0x43fc: 0x0008, 0x43fd: 0x0008, 0x43ff: 0x0008, // Block 0x110, offset 0x4400 0x4400: 0x0008, 0x4401: 0x0008, 0x4402: 0x0008, 0x4403: 0x0008, 0x4404: 0x0008, 0x4405: 0x0008, 0x4406: 0x0100, 0x4407: 0x0008, 0x4410: 0x0080, 0x4411: 0x0080, 0x4412: 0x0080, 0x4413: 0x0080, 0x4414: 0x0080, 0x4415: 0x0080, 0x4416: 0x0080, 0x4417: 0x0080, 0x4418: 0x0080, 0x4419: 0x0080, 0x4420: 0x0100, 0x4421: 0x0100, 0x4422: 0x0100, 0x4423: 0x0100, 0x4424: 0x0100, 0x4425: 0x0100, 0x4427: 0x0100, 0x4428: 0x0100, 0x442a: 0x0100, 0x442b: 0x0100, 0x442c: 0x0100, 0x442d: 0x0100, 0x442e: 0x0100, 0x442f: 0x0100, 0x4430: 0x0100, 0x4431: 0x0100, 0x4432: 0x0100, 0x4433: 0x0100, 0x4434: 0x0100, 0x4435: 0x0100, 0x4436: 0x0100, 0x4437: 0x0100, 0x4438: 0x0100, 0x4439: 0x0100, 0x443a: 0x0100, 0x443b: 0x0100, 0x443c: 0x0100, 0x443d: 0x0100, 0x443e: 0x0100, 0x443f: 0x0100, // Block 0x111, offset 0x4440 0x4440: 0x0100, 0x4441: 0x0100, 0x4442: 0x0100, 0x4443: 0x0100, 0x4444: 0x0100, 0x4445: 0x0100, 0x4446: 0x0100, 0x4447: 0x0100, 0x4448: 0x0100, 0x4449: 0x0100, 0x444a: 0x0008, 0x444b: 0x0008, 0x444c: 0x0008, 0x444d: 0x0008, 0x444e: 0x0008, 0x4450: 0x0008, 0x4451: 0x0008, 0x4453: 0x0008, 0x4454: 0x0008, 0x4455: 0x0008, 0x4456: 0x0008, 0x4457: 0x0008, 0x4458: 0x0100, 0x4460: 0x0080, 0x4461: 0x0080, 0x4462: 0x0080, 0x4463: 0x0080, 0x4464: 0x0080, 0x4465: 0x0080, 0x4466: 0x0080, 0x4467: 0x0080, 0x4468: 0x0080, 0x4469: 0x0080, 0x4470: 0x0100, 0x4471: 0x0100, 0x4472: 0x0100, 0x4473: 0x0100, 0x4474: 0x0100, 0x4475: 0x0100, 0x4476: 0x0100, 0x4477: 0x0100, 0x4478: 0x0100, 0x4479: 0x0100, 0x447a: 0x0100, 0x447b: 0x0100, 0x447c: 0x0100, 0x447d: 0x0100, 0x447e: 0x0100, 0x447f: 0x0100, // Block 0x112, offset 0x4480 0x4480: 0x0100, 0x4481: 0x0100, 0x4482: 0x0100, 0x4483: 0x0100, 0x4484: 0x0100, 0x4485: 0x0100, 0x4486: 0x0100, 0x4487: 0x0100, 0x4488: 0x0100, 0x4489: 0x0100, 0x448a: 0x0100, 0x448b: 0x0100, 0x448c: 0x0100, 0x448d: 0x0100, 0x448e: 0x0100, 0x448f: 0x0100, 0x4490: 0x0100, 0x4491: 0x0100, 0x4492: 0x0100, 0x4493: 0x0100, 0x4494: 0x0100, 0x4495: 0x0100, 0x4496: 0x0100, 0x4497: 0x0100, 0x4498: 0x0100, 0x4499: 0x0100, 0x449a: 0x0100, 0x449b: 0x0100, 0x44a0: 0x0080, 0x44a1: 0x0080, 0x44a2: 0x0080, 0x44a3: 0x0080, 0x44a4: 0x0080, 0x44a5: 0x0080, 0x44a6: 0x0080, 0x44a7: 0x0080, 0x44a8: 0x0080, 0x44a9: 0x0080, // Block 0x113, offset 0x44c0 0x44e0: 0x0100, 0x44e1: 0x0100, 0x44e2: 0x0100, 0x44e3: 0x0100, 0x44e4: 0x0100, 0x44e5: 0x0100, 0x44e6: 0x0100, 0x44e7: 0x0100, 0x44e8: 0x0100, 0x44e9: 0x0100, 0x44ea: 0x0100, 0x44eb: 0x0100, 0x44ec: 0x0100, 0x44ed: 0x0100, 0x44ee: 0x0100, 0x44ef: 0x0100, 0x44f0: 0x0100, 0x44f1: 0x0100, 0x44f2: 0x0100, 0x44f3: 0x0008, 0x44f4: 0x0008, 0x44f5: 0x0008, 0x44f6: 0x0008, 0x44f7: 0x0400, 0x44f8: 0x0400, // Block 0x114, offset 0x4500 0x4500: 0x0008, 0x4501: 0x0008, 0x4502: 0x0100, 0x4503: 0x0008, 0x4504: 0x0100, 0x4505: 0x0100, 0x4506: 0x0100, 0x4507: 0x0100, 0x4508: 0x0100, 0x4509: 0x0100, 0x450a: 0x0100, 0x450b: 0x0100, 0x450c: 0x0100, 0x450d: 0x0100, 0x450e: 0x0100, 0x450f: 0x0100, 0x4510: 0x0100, 0x4512: 0x0100, 0x4513: 0x0100, 0x4514: 0x0100, 0x4515: 0x0100, 0x4516: 0x0100, 0x4517: 0x0100, 0x4518: 0x0100, 0x4519: 0x0100, 0x451a: 0x0100, 0x451b: 0x0100, 0x451c: 0x0100, 0x451d: 0x0100, 0x451e: 0x0100, 0x451f: 0x0100, 0x4520: 0x0100, 0x4521: 0x0100, 0x4522: 0x0100, 0x4523: 0x0100, 0x4524: 0x0100, 0x4525: 0x0100, 0x4526: 0x0100, 0x4527: 0x0100, 0x4528: 0x0100, 0x4529: 0x0100, 0x452a: 0x0100, 0x452b: 0x0100, 0x452c: 0x0100, 0x452d: 0x0100, 0x452e: 0x0100, 0x452f: 0x0100, 0x4530: 0x0100, 0x4531: 0x0100, 0x4532: 0x0100, 0x4533: 0x0100, 0x4534: 0x0008, 0x4535: 0x0008, 0x4536: 0x0008, 0x4537: 0x0008, 0x4538: 0x0008, 0x4539: 0x0008, 0x453a: 0x0008, 0x453e: 0x0008, 0x453f: 0x0008, // Block 0x115, offset 0x4540 0x4540: 0x0008, 0x4541: 0x0008, 0x4542: 0x0008, 0x4543: 0x0400, 0x4544: 0x0400, 0x4550: 0x0080, 0x4551: 0x0080, 0x4552: 0x0080, 0x4553: 0x0080, 0x4554: 0x0080, 0x4555: 0x0080, 0x4556: 0x0080, 0x4557: 0x0080, 0x4558: 0x0080, 0x4559: 0x0080, 0x455a: 0x0008, // Block 0x116, offset 0x4580 0x45b0: 0x0100, // Block 0x117, offset 0x45c0 0x45c0: 0x0100, 0x45c1: 0x0100, 0x45c2: 0x0100, 0x45c3: 0x0100, 0x45c4: 0x0100, 0x45c5: 0x0100, 0x45c6: 0x0100, 0x45c7: 0x0100, 0x45c8: 0x0100, 0x45c9: 0x0100, 0x45ca: 0x0100, 0x45cb: 0x0100, 0x45cc: 0x0100, 0x45cd: 0x0100, 0x45ce: 0x0100, 0x45cf: 0x0100, 0x45d0: 0x0100, 0x45d1: 0x0100, 0x45d2: 0x0100, 0x45d3: 0x0100, 0x45d4: 0x0100, 0x45d5: 0x0100, 0x45d6: 0x0100, 0x45d7: 0x0100, 0x45d8: 0x0100, 0x45d9: 0x0100, 0x45da: 0x0100, 0x45db: 0x0100, 0x45dc: 0x0100, 0x45dd: 0x0100, 0x45de: 0x0100, 0x45df: 0x0100, 0x45e0: 0x0100, 0x45e1: 0x0100, 0x45e2: 0x0100, 0x45e3: 0x0100, 0x45e4: 0x0100, 0x45e5: 0x0100, 0x45e6: 0x0100, 0x45e7: 0x0100, 0x45e8: 0x0100, 0x45e9: 0x0100, 0x45ea: 0x0100, 0x45eb: 0x0100, 0x45ec: 0x0100, 0x45ed: 0x0100, 0x45ee: 0x0100, // Block 0x118, offset 0x4600 0x4600: 0x0100, 0x4601: 0x0100, 0x4602: 0x0100, 0x4603: 0x0100, // Block 0x119, offset 0x4640 0x4640: 0x0100, 0x4641: 0x0100, 0x4642: 0x0100, 0x4643: 0x0100, 0x4644: 0x0100, 0x4645: 0x0100, 0x4646: 0x0100, 0x4647: 0x0100, 0x4648: 0x0100, 0x4649: 0x0100, 0x464a: 0x0100, 0x464b: 0x0100, 0x464c: 0x0100, 0x464d: 0x0100, 0x464e: 0x0100, 0x464f: 0x0100, 0x4650: 0x0100, 0x4651: 0x0100, 0x4652: 0x0100, 0x4653: 0x0100, 0x4654: 0x0100, 0x4655: 0x0100, 0x4656: 0x0100, 0x4657: 0x0100, 0x4658: 0x0100, 0x4659: 0x0100, 0x465a: 0x0100, 0x465b: 0x0100, 0x465c: 0x0100, 0x465d: 0x0100, 0x465e: 0x0100, 0x465f: 0x0100, 0x4660: 0x0100, 0x4661: 0x0100, 0x4662: 0x0100, 0x4663: 0x0100, 0x4664: 0x0100, 0x4665: 0x0100, 0x4666: 0x0100, 0x4667: 0x0100, 0x4668: 0x0100, 0x4669: 0x0100, 0x466a: 0x0100, 0x466b: 0x0100, 0x466c: 0x0100, 0x466d: 0x0100, 0x466e: 0x0100, 0x466f: 0x0100, 0x4670: 0x0100, // Block 0x11a, offset 0x4680 0x4680: 0x0100, 0x4681: 0x0100, 0x4682: 0x0100, 0x4683: 0x0100, 0x4684: 0x0100, 0x4685: 0x0100, 0x4686: 0x0100, 0x4687: 0x0100, 0x4688: 0x0100, 0x4689: 0x0100, 0x468a: 0x0100, 0x468b: 0x0100, 0x468c: 0x0100, 0x468d: 0x0100, 0x468e: 0x0100, 0x468f: 0x0100, 0x4690: 0x0100, 0x4691: 0x0100, 0x4692: 0x0100, 0x4693: 0x0100, 0x4694: 0x0100, 0x4695: 0x0100, 0x4696: 0x0100, 0x4697: 0x0100, 0x4698: 0x0100, 0x4699: 0x0100, 0x469a: 0x0100, 0x469b: 0x0100, 0x469c: 0x0100, 0x469d: 0x0100, 0x469e: 0x0100, 0x469f: 0x0100, 0x46a0: 0x0100, 0x46a1: 0x0100, 0x46a2: 0x0100, 0x46a3: 0x0100, 0x46a4: 0x0100, 0x46a5: 0x0100, 0x46a6: 0x0100, 0x46a7: 0x0100, 0x46a8: 0x0100, 0x46a9: 0x0100, 0x46aa: 0x0100, 0x46ab: 0x0100, 0x46ac: 0x0100, 0x46ad: 0x0100, 0x46ae: 0x0100, 0x46af: 0x0100, 0x46b0: 0x0010, 0x46b1: 0x0010, 0x46b2: 0x0010, 0x46b3: 0x0010, 0x46b4: 0x0010, 0x46b5: 0x0010, 0x46b6: 0x0010, 0x46b7: 0x0010, 0x46b8: 0x0010, 0x46b9: 0x0010, 0x46ba: 0x0010, 0x46bb: 0x0010, 0x46bc: 0x0010, 0x46bd: 0x0010, 0x46be: 0x0010, 0x46bf: 0x0010, // Block 0x11b, offset 0x46c0 0x46c0: 0x0008, 0x46c1: 0x0100, 0x46c2: 0x0100, 0x46c3: 0x0100, 0x46c4: 0x0100, 0x46c5: 0x0100, 0x46c6: 0x0100, 0x46c7: 0x0008, 0x46c8: 0x0008, 0x46c9: 0x0008, 0x46ca: 0x0008, 0x46cb: 0x0008, 0x46cc: 0x0008, 0x46cd: 0x0008, 0x46ce: 0x0008, 0x46cf: 0x0008, 0x46d0: 0x0008, 0x46d1: 0x0008, 0x46d2: 0x0008, 0x46d3: 0x0008, 0x46d4: 0x0008, 0x46d5: 0x0008, 0x46e0: 0x0100, 0x46e1: 0x0100, 0x46e2: 0x0100, 0x46e3: 0x0100, 0x46e4: 0x0100, 0x46e5: 0x0100, 0x46e6: 0x0100, 0x46e7: 0x0100, 0x46e8: 0x0100, 0x46e9: 0x0100, 0x46ea: 0x0100, 0x46eb: 0x0100, 0x46ec: 0x0100, 0x46ed: 0x0100, 0x46ee: 0x0100, 0x46ef: 0x0100, 0x46f0: 0x0100, 0x46f1: 0x0100, 0x46f2: 0x0100, 0x46f3: 0x0100, 0x46f4: 0x0100, 0x46f5: 0x0100, 0x46f6: 0x0100, 0x46f7: 0x0100, 0x46f8: 0x0100, 0x46f9: 0x0100, 0x46fa: 0x0100, 0x46fb: 0x0100, 0x46fc: 0x0100, 0x46fd: 0x0100, 0x46fe: 0x0100, 0x46ff: 0x0100, // Block 0x11c, offset 0x4700 0x4700: 0x0100, 0x4701: 0x0100, 0x4702: 0x0100, 0x4703: 0x0100, 0x4704: 0x0100, 0x4705: 0x0100, 0x4706: 0x0100, 0x4707: 0x0100, 0x4708: 0x0100, 0x4709: 0x0100, 0x470a: 0x0100, 0x470b: 0x0100, 0x470c: 0x0100, 0x470d: 0x0100, 0x470e: 0x0100, 0x470f: 0x0100, 0x4710: 0x0100, 0x4711: 0x0100, 0x4712: 0x0100, 0x4713: 0x0100, 0x4714: 0x0100, 0x4715: 0x0100, 0x4716: 0x0100, 0x4717: 0x0100, 0x4718: 0x0100, 0x4719: 0x0100, 0x471a: 0x0100, 0x471b: 0x0100, 0x471c: 0x0100, 0x471d: 0x0100, 0x471e: 0x0008, 0x471f: 0x0008, 0x4720: 0x0008, 0x4721: 0x0008, 0x4722: 0x0008, 0x4723: 0x0008, 0x4724: 0x0008, 0x4725: 0x0008, 0x4726: 0x0008, 0x4727: 0x0008, 0x4728: 0x0008, 0x4729: 0x0008, 0x472a: 0x0008, 0x472b: 0x0008, 0x472c: 0x0008, 0x472d: 0x0008, 0x472e: 0x0008, 0x472f: 0x0008, 0x4730: 0x0080, 0x4731: 0x0080, 0x4732: 0x0080, 0x4733: 0x0080, 0x4734: 0x0080, 0x4735: 0x0080, 0x4736: 0x0080, 0x4737: 0x0080, 0x4738: 0x0080, 0x4739: 0x0080, // Block 0x11d, offset 0x4740 0x4740: 0x0100, 0x4741: 0x0100, 0x4742: 0x0100, 0x4743: 0x0100, 0x4744: 0x0100, 0x4745: 0x0100, 0x4746: 0x0100, 0x4747: 0x0100, 0x4748: 0x0100, 0x4749: 0x0100, 0x474a: 0x0100, 0x474b: 0x0100, 0x474c: 0x0100, 0x474d: 0x0100, 0x474e: 0x0100, 0x474f: 0x0100, 0x4750: 0x0100, 0x4751: 0x0100, 0x4752: 0x0100, 0x4753: 0x0100, 0x4754: 0x0100, 0x4755: 0x0100, 0x4756: 0x0100, 0x4757: 0x0100, 0x4758: 0x0100, 0x4759: 0x0100, 0x475a: 0x0100, 0x475b: 0x0100, 0x475c: 0x0100, 0x475d: 0x0100, 0x475e: 0x0100, 0x4760: 0x0080, 0x4761: 0x0080, 0x4762: 0x0080, 0x4763: 0x0080, 0x4764: 0x0080, 0x4765: 0x0080, 0x4766: 0x0080, 0x4767: 0x0080, 0x4768: 0x0080, 0x4769: 0x0080, 0x476e: 0x0400, 0x476f: 0x0400, 0x4770: 0x0100, 0x4771: 0x0100, 0x4772: 0x0100, 0x4773: 0x0100, 0x4774: 0x0100, 0x4775: 0x0100, 0x4776: 0x0100, 0x4777: 0x0100, 0x4778: 0x0100, 0x4779: 0x0100, 0x477a: 0x0100, 0x477b: 0x0100, 0x477c: 0x0100, 0x477d: 0x0100, 0x477e: 0x0100, 0x477f: 0x0100, // Block 0x11e, offset 0x4780 0x4780: 0x0100, 0x4781: 0x0100, 0x4782: 0x0100, 0x4783: 0x0100, 0x4784: 0x0100, 0x4785: 0x0100, 0x4786: 0x0100, 0x4787: 0x0100, 0x4788: 0x0100, 0x4789: 0x0100, 0x478a: 0x0100, 0x478b: 0x0100, 0x478c: 0x0100, 0x478d: 0x0100, 0x478e: 0x0100, 0x478f: 0x0100, 0x4790: 0x0100, 0x4791: 0x0100, 0x4792: 0x0100, 0x4793: 0x0100, 0x4794: 0x0100, 0x4795: 0x0100, 0x4796: 0x0100, 0x4797: 0x0100, 0x4798: 0x0100, 0x4799: 0x0100, 0x479a: 0x0100, 0x479b: 0x0100, 0x479c: 0x0100, 0x479d: 0x0100, 0x479e: 0x0100, 0x479f: 0x0100, 0x47a0: 0x0100, 0x47a1: 0x0100, 0x47a2: 0x0100, 0x47a3: 0x0100, 0x47a4: 0x0100, 0x47a5: 0x0100, 0x47a6: 0x0100, 0x47a7: 0x0100, 0x47a8: 0x0100, 0x47a9: 0x0100, 0x47aa: 0x0100, 0x47ab: 0x0100, 0x47ac: 0x0100, 0x47ad: 0x0100, 0x47ae: 0x0100, 0x47af: 0x0100, 0x47b0: 0x0100, 0x47b1: 0x0100, 0x47b2: 0x0100, 0x47b3: 0x0100, 0x47b4: 0x0100, 0x47b5: 0x0100, 0x47b6: 0x0100, 0x47b7: 0x0100, 0x47b8: 0x0100, 0x47b9: 0x0100, 0x47ba: 0x0100, 0x47bb: 0x0100, 0x47bc: 0x0100, 0x47bd: 0x0100, 0x47be: 0x0100, // Block 0x11f, offset 0x47c0 0x47c0: 0x0080, 0x47c1: 0x0080, 0x47c2: 0x0080, 0x47c3: 0x0080, 0x47c4: 0x0080, 0x47c5: 0x0080, 0x47c6: 0x0080, 0x47c7: 0x0080, 0x47c8: 0x0080, 0x47c9: 0x0080, 0x47d0: 0x0100, 0x47d1: 0x0100, 0x47d2: 0x0100, 0x47d3: 0x0100, 0x47d4: 0x0100, 0x47d5: 0x0100, 0x47d6: 0x0100, 0x47d7: 0x0100, 0x47d8: 0x0100, 0x47d9: 0x0100, 0x47da: 0x0100, 0x47db: 0x0100, 0x47dc: 0x0100, 0x47dd: 0x0100, 0x47de: 0x0100, 0x47df: 0x0100, 0x47e0: 0x0100, 0x47e1: 0x0100, 0x47e2: 0x0100, 0x47e3: 0x0100, 0x47e4: 0x0100, 0x47e5: 0x0100, 0x47e6: 0x0100, 0x47e7: 0x0100, 0x47e8: 0x0100, 0x47e9: 0x0100, 0x47ea: 0x0100, 0x47eb: 0x0100, 0x47ec: 0x0100, 0x47ed: 0x0100, 0x47f0: 0x0008, 0x47f1: 0x0008, 0x47f2: 0x0008, 0x47f3: 0x0008, 0x47f4: 0x0008, 0x47f5: 0x0400, // Block 0x120, offset 0x4800 0x4800: 0x0100, 0x4801: 0x0100, 0x4802: 0x0100, 0x4803: 0x0100, 0x4804: 0x0100, 0x4805: 0x0100, 0x4806: 0x0100, 0x4807: 0x0100, 0x4808: 0x0100, 0x4809: 0x0100, 0x480a: 0x0100, 0x480b: 0x0100, 0x480c: 0x0100, 0x480d: 0x0100, 0x480e: 0x0100, 0x480f: 0x0100, 0x4810: 0x0100, 0x4811: 0x0100, 0x4812: 0x0100, 0x4813: 0x0100, 0x4814: 0x0100, 0x4815: 0x0100, 0x4816: 0x0100, 0x4817: 0x0100, 0x4818: 0x0100, 0x4819: 0x0100, 0x481a: 0x0100, 0x481b: 0x0100, 0x481c: 0x0100, 0x481d: 0x0100, 0x481e: 0x0100, 0x481f: 0x0100, 0x4820: 0x0100, 0x4821: 0x0100, 0x4822: 0x0100, 0x4823: 0x0100, 0x4824: 0x0100, 0x4825: 0x0100, 0x4826: 0x0100, 0x4827: 0x0100, 0x4828: 0x0100, 0x4829: 0x0100, 0x482a: 0x0100, 0x482b: 0x0100, 0x482c: 0x0100, 0x482d: 0x0100, 0x482e: 0x0100, 0x482f: 0x0100, 0x4830: 0x0008, 0x4831: 0x0008, 0x4832: 0x0008, 0x4833: 0x0008, 0x4834: 0x0008, 0x4835: 0x0008, 0x4836: 0x0008, 0x4837: 0x0400, 0x4838: 0x0400, // Block 0x121, offset 0x4840 0x4840: 0x0100, 0x4841: 0x0100, 0x4842: 0x0100, 0x4843: 0x0100, 0x4844: 0x0400, 0x4850: 0x0080, 0x4851: 0x0080, 0x4852: 0x0080, 0x4853: 0x0080, 0x4854: 0x0080, 0x4855: 0x0080, 0x4856: 0x0080, 0x4857: 0x0080, 0x4858: 0x0080, 0x4859: 0x0080, 0x4863: 0x0100, 0x4864: 0x0100, 0x4865: 0x0100, 0x4866: 0x0100, 0x4867: 0x0100, 0x4868: 0x0100, 0x4869: 0x0100, 0x486a: 0x0100, 0x486b: 0x0100, 0x486c: 0x0100, 0x486d: 0x0100, 0x486e: 0x0100, 0x486f: 0x0100, 0x4870: 0x0100, 0x4871: 0x0100, 0x4872: 0x0100, 0x4873: 0x0100, 0x4874: 0x0100, 0x4875: 0x0100, 0x4876: 0x0100, 0x4877: 0x0100, 0x487d: 0x0100, 0x487e: 0x0100, 0x487f: 0x0100, // Block 0x122, offset 0x4880 0x4880: 0x0100, 0x4881: 0x0100, 0x4882: 0x0100, 0x4883: 0x0100, 0x4884: 0x0100, 0x4885: 0x0100, 0x4886: 0x0100, 0x4887: 0x0100, 0x4888: 0x0100, 0x4889: 0x0100, 0x488a: 0x0100, 0x488b: 0x0100, 0x488c: 0x0100, 0x488d: 0x0100, 0x488e: 0x0100, 0x488f: 0x0100, // Block 0x123, offset 0x48c0 0x48c0: 0x0100, 0x48c1: 0x0100, 0x48c2: 0x0100, 0x48c3: 0x0100, 0x48c4: 0x0100, 0x48c5: 0x0100, 0x48c6: 0x0100, 0x48c7: 0x0100, 0x48c8: 0x0100, 0x48c9: 0x0100, 0x48ca: 0x0100, 0x48cb: 0x0100, 0x48cc: 0x0100, 0x48cd: 0x0100, 0x48ce: 0x0100, 0x48cf: 0x0100, 0x48d0: 0x0100, 0x48d1: 0x0100, 0x48d2: 0x0100, 0x48d3: 0x0100, 0x48d4: 0x0100, 0x48d5: 0x0100, 0x48d6: 0x0100, 0x48d7: 0x0100, 0x48d8: 0x0100, 0x48d9: 0x0100, 0x48da: 0x0100, 0x48db: 0x0100, 0x48dc: 0x0100, 0x48dd: 0x0100, 0x48de: 0x0100, 0x48df: 0x0100, 0x48e0: 0x0100, 0x48e1: 0x0100, 0x48e2: 0x0100, 0x48e3: 0x0100, 0x48e4: 0x0100, 0x48e5: 0x0100, 0x48e6: 0x0100, 0x48e7: 0x0100, 0x48e8: 0x0100, 0x48e9: 0x0100, 0x48ea: 0x0100, 0x48eb: 0x0100, 0x48ec: 0x0100, 0x48ee: 0x0400, 0x48ef: 0x0400, 0x48f0: 0x0080, 0x48f1: 0x0080, 0x48f2: 0x0080, 0x48f3: 0x0080, 0x48f4: 0x0080, 0x48f5: 0x0080, 0x48f6: 0x0080, 0x48f7: 0x0080, 0x48f8: 0x0080, 0x48f9: 0x0080, // Block 0x124, offset 0x4900 0x4900: 0x2000, 0x4901: 0x2000, 0x4902: 0x2000, 0x4903: 0x2000, 0x4904: 0x2000, 0x4905: 0x2000, 0x4906: 0x2000, 0x4907: 0x2000, 0x4908: 0x2000, 0x4909: 0x2000, 0x490a: 0x2000, 0x490b: 0x2000, 0x490c: 0x2000, 0x490d: 0x2000, 0x490e: 0x2000, 0x490f: 0x2000, 0x4910: 0x2000, 0x4911: 0x2000, 0x4912: 0x2000, 0x4913: 0x2000, 0x4914: 0x2000, 0x4915: 0x2000, 0x4916: 0x2000, 0x4917: 0x2000, 0x4918: 0x2000, 0x4919: 0x2000, 0x491a: 0x2000, 0x491b: 0x2000, 0x491c: 0x2000, 0x491d: 0x2000, 0x491e: 0x2000, 0x491f: 0x2000, 0x4920: 0x0040, 0x4921: 0x0040, 0x4922: 0x0040, 0x4923: 0x0040, 0x4924: 0x0040, 0x4925: 0x0040, 0x4926: 0x0040, 0x4927: 0x0040, 0x4928: 0x0040, 0x4929: 0x0040, 0x492a: 0x0040, 0x492b: 0x0040, 0x492c: 0x0040, 0x492d: 0x0040, 0x492e: 0x0040, 0x492f: 0x0040, 0x4930: 0x0040, 0x4931: 0x0040, 0x4932: 0x0040, 0x4933: 0x0040, 0x4934: 0x0040, 0x4935: 0x0040, 0x4936: 0x0040, 0x4937: 0x0040, 0x4938: 0x0040, 0x4939: 0x0040, 0x493a: 0x0040, 0x493b: 0x0040, 0x493c: 0x0040, 0x493d: 0x0040, 0x493e: 0x0040, 0x493f: 0x0040, // Block 0x125, offset 0x4940 0x4958: 0x0400, 0x4960: 0x2000, 0x4961: 0x2000, 0x4962: 0x2000, 0x4963: 0x2000, 0x4964: 0x2000, 0x4965: 0x2000, 0x4966: 0x2000, 0x4967: 0x2000, 0x4968: 0x2000, 0x4969: 0x2000, 0x496a: 0x2000, 0x496b: 0x2000, 0x496c: 0x2000, 0x496d: 0x2000, 0x496e: 0x2000, 0x496f: 0x2000, 0x4970: 0x2000, 0x4971: 0x2000, 0x4972: 0x2000, 0x4973: 0x2000, 0x4974: 0x2000, 0x4975: 0x2000, 0x4976: 0x2000, 0x4977: 0x2000, 0x4978: 0x2000, 0x497b: 0x0040, 0x497c: 0x0040, 0x497d: 0x0040, 0x497e: 0x0040, 0x497f: 0x0040, // Block 0x126, offset 0x4980 0x4980: 0x0040, 0x4981: 0x0040, 0x4982: 0x0040, 0x4983: 0x0040, 0x4984: 0x0040, 0x4985: 0x0040, 0x4986: 0x0040, 0x4987: 0x0040, 0x4988: 0x0040, 0x4989: 0x0040, 0x498a: 0x0040, 0x498b: 0x0040, 0x498c: 0x0040, 0x498d: 0x0040, 0x498e: 0x0040, 0x498f: 0x0040, 0x4990: 0x0040, 0x4991: 0x0040, 0x4992: 0x0040, 0x4993: 0x0040, // Block 0x127, offset 0x49c0 0x49c0: 0x0100, 0x49c1: 0x0100, 0x49c2: 0x0100, 0x49c3: 0x0100, 0x49c4: 0x0100, 0x49c5: 0x0100, 0x49c6: 0x0100, 0x49c7: 0x0100, 0x49c8: 0x0100, 0x49c9: 0x0100, 0x49ca: 0x0100, 0x49cf: 0x0008, 0x49d0: 0x0100, 0x49d1: 0x0008, 0x49d2: 0x0008, 0x49d3: 0x0008, 0x49d4: 0x0008, 0x49d5: 0x0008, 0x49d6: 0x0008, 0x49d7: 0x0008, 0x49d8: 0x0008, 0x49d9: 0x0008, 0x49da: 0x0008, 0x49db: 0x0008, 0x49dc: 0x0008, 0x49dd: 0x0008, 0x49de: 0x0008, 0x49df: 0x0008, 0x49e0: 0x0008, 0x49e1: 0x0008, 0x49e2: 0x0008, 0x49e3: 0x0008, 0x49e4: 0x0008, 0x49e5: 0x0008, 0x49e6: 0x0008, 0x49e7: 0x0008, 0x49e8: 0x0008, 0x49e9: 0x0008, 0x49ea: 0x0008, 0x49eb: 0x0008, 0x49ec: 0x0008, 0x49ed: 0x0008, 0x49ee: 0x0008, 0x49ef: 0x0008, 0x49f0: 0x0008, 0x49f1: 0x0008, 0x49f2: 0x0008, 0x49f3: 0x0008, 0x49f4: 0x0008, 0x49f5: 0x0008, 0x49f6: 0x0008, 0x49f7: 0x0008, 0x49f8: 0x0008, 0x49f9: 0x0008, 0x49fa: 0x0008, 0x49fb: 0x0008, 0x49fc: 0x0008, 0x49fd: 0x0008, 0x49fe: 0x0008, 0x49ff: 0x0008, // Block 0x128, offset 0x4a00 0x4a00: 0x0008, 0x4a01: 0x0008, 0x4a02: 0x0008, 0x4a03: 0x0008, 0x4a04: 0x0008, 0x4a05: 0x0008, 0x4a06: 0x0008, 0x4a07: 0x0008, 0x4a0f: 0x0008, 0x4a10: 0x0008, 0x4a11: 0x0008, 0x4a12: 0x0008, 0x4a13: 0x0100, 0x4a14: 0x0100, 0x4a15: 0x0100, 0x4a16: 0x0100, 0x4a17: 0x0100, 0x4a18: 0x0100, 0x4a19: 0x0100, 0x4a1a: 0x0100, 0x4a1b: 0x0100, 0x4a1c: 0x0100, 0x4a1d: 0x0100, 0x4a1e: 0x0100, 0x4a1f: 0x0100, // Block 0x129, offset 0x4a40 0x4a60: 0x0100, 0x4a61: 0x0100, 0x4a63: 0x0100, 0x4a64: 0x0008, 0x4a70: 0x0008, 0x4a71: 0x0008, 0x4a72: 0x0100, 0x4a73: 0x0100, 0x4a74: 0x0100, 0x4a75: 0x0100, 0x4a76: 0x0100, // Block 0x12a, offset 0x4a80 0x4a80: 0x0100, 0x4a81: 0x0100, 0x4a82: 0x0100, 0x4a83: 0x0100, 0x4a84: 0x0100, 0x4a85: 0x0100, 0x4a86: 0x0100, 0x4a87: 0x0100, 0x4a88: 0x0100, 0x4a89: 0x0100, 0x4a8a: 0x0100, 0x4a8b: 0x0100, 0x4a8c: 0x0100, 0x4a8d: 0x0100, 0x4a8e: 0x0100, 0x4a8f: 0x0100, 0x4a90: 0x0100, 0x4a91: 0x0100, 0x4a92: 0x0100, 0x4a93: 0x0100, 0x4a94: 0x0100, 0x4a95: 0x0100, 0x4abf: 0x0100, // Block 0x12b, offset 0x4ac0 0x4ac0: 0x0100, 0x4ac1: 0x0100, 0x4ac2: 0x0100, 0x4ac3: 0x0100, 0x4ac4: 0x0100, 0x4ac5: 0x0100, 0x4ac6: 0x0100, 0x4ac7: 0x0100, 0x4ac8: 0x0100, 0x4ac9: 0x0100, 0x4aca: 0x0100, 0x4acb: 0x0100, 0x4acc: 0x0100, 0x4acd: 0x0100, 0x4ace: 0x0100, 0x4acf: 0x0100, 0x4ad0: 0x0100, 0x4ad1: 0x0100, 0x4ad2: 0x0100, 0x4ad3: 0x0100, 0x4ad4: 0x0100, 0x4ad5: 0x0100, 0x4ad6: 0x0100, 0x4ad7: 0x0100, 0x4ad8: 0x0100, 0x4ad9: 0x0100, 0x4ada: 0x0100, 0x4adb: 0x0100, 0x4adc: 0x0100, 0x4add: 0x0100, 0x4ade: 0x0100, 0x4adf: 0x0100, 0x4ae0: 0x0100, 0x4ae1: 0x0100, 0x4ae2: 0x0100, 0x4ae3: 0x0100, 0x4ae4: 0x0100, 0x4ae5: 0x0100, 0x4ae6: 0x0100, 0x4ae7: 0x0100, 0x4ae8: 0x0100, 0x4ae9: 0x0100, 0x4aea: 0x0100, 0x4aeb: 0x0100, 0x4aec: 0x0100, 0x4aed: 0x0100, 0x4aee: 0x0100, 0x4aef: 0x0100, 0x4af0: 0x0100, 0x4af1: 0x0100, 0x4af2: 0x0100, // Block 0x12c, offset 0x4b00 0x4b30: 0x0100, 0x4b31: 0x0100, 0x4b32: 0x0100, 0x4b33: 0x0100, 0x4b35: 0x0100, 0x4b36: 0x0100, 0x4b37: 0x0100, 0x4b38: 0x0100, 0x4b39: 0x0100, 0x4b3a: 0x0100, 0x4b3b: 0x0100, 0x4b3d: 0x0100, 0x4b3e: 0x0100, // Block 0x12d, offset 0x4b40 0x4b40: 0x0100, 0x4b41: 0x0100, 0x4b42: 0x0100, 0x4b43: 0x0100, 0x4b44: 0x0100, 0x4b45: 0x0100, 0x4b46: 0x0100, 0x4b47: 0x0100, 0x4b48: 0x0100, 0x4b49: 0x0100, 0x4b4a: 0x0100, 0x4b4b: 0x0100, 0x4b4c: 0x0100, 0x4b4d: 0x0100, 0x4b4e: 0x0100, 0x4b4f: 0x0100, 0x4b50: 0x0100, 0x4b51: 0x0100, 0x4b52: 0x0100, 0x4b53: 0x0100, 0x4b54: 0x0100, 0x4b55: 0x0100, 0x4b56: 0x0100, 0x4b57: 0x0100, 0x4b58: 0x0100, 0x4b59: 0x0100, 0x4b5a: 0x0100, 0x4b5b: 0x0100, 0x4b5c: 0x0100, 0x4b5d: 0x0100, 0x4b5e: 0x0100, 0x4b5f: 0x0100, 0x4b60: 0x0100, 0x4b61: 0x0100, 0x4b62: 0x0100, 0x4b72: 0x0100, // Block 0x12e, offset 0x4b80 0x4b90: 0x0100, 0x4b91: 0x0100, 0x4b92: 0x0100, 0x4b95: 0x0100, 0x4ba4: 0x0100, 0x4ba5: 0x0100, 0x4ba6: 0x0100, 0x4ba7: 0x0100, 0x4bb0: 0x0100, 0x4bb1: 0x0100, 0x4bb2: 0x0100, 0x4bb3: 0x0100, 0x4bb4: 0x0100, 0x4bb5: 0x0100, 0x4bb6: 0x0100, 0x4bb7: 0x0100, 0x4bb8: 0x0100, 0x4bb9: 0x0100, 0x4bba: 0x0100, 0x4bbb: 0x0100, 0x4bbc: 0x0100, 0x4bbd: 0x0100, 0x4bbe: 0x0100, 0x4bbf: 0x0100, // Block 0x12f, offset 0x4bc0 0x4bc0: 0x0100, 0x4bc1: 0x0100, 0x4bc2: 0x0100, 0x4bc3: 0x0100, 0x4bc4: 0x0100, 0x4bc5: 0x0100, 0x4bc6: 0x0100, 0x4bc7: 0x0100, 0x4bc8: 0x0100, 0x4bc9: 0x0100, 0x4bca: 0x0100, 0x4bcb: 0x0100, 0x4bcc: 0x0100, 0x4bcd: 0x0100, 0x4bce: 0x0100, 0x4bcf: 0x0100, 0x4bd0: 0x0100, 0x4bd1: 0x0100, 0x4bd2: 0x0100, 0x4bd3: 0x0100, 0x4bd4: 0x0100, 0x4bd5: 0x0100, 0x4bd6: 0x0100, 0x4bd7: 0x0100, 0x4bd8: 0x0100, 0x4bd9: 0x0100, 0x4bda: 0x0100, 0x4bdb: 0x0100, 0x4bdc: 0x0100, 0x4bdd: 0x0100, 0x4bde: 0x0100, 0x4bdf: 0x0100, 0x4be0: 0x0100, 0x4be1: 0x0100, 0x4be2: 0x0100, 0x4be3: 0x0100, 0x4be4: 0x0100, 0x4be5: 0x0100, 0x4be6: 0x0100, 0x4be7: 0x0100, 0x4be8: 0x0100, 0x4be9: 0x0100, 0x4bea: 0x0100, 0x4beb: 0x0100, 0x4bec: 0x0100, 0x4bed: 0x0100, 0x4bee: 0x0100, 0x4bef: 0x0100, 0x4bf0: 0x0100, 0x4bf1: 0x0100, 0x4bf2: 0x0100, 0x4bf3: 0x0100, 0x4bf4: 0x0100, 0x4bf5: 0x0100, 0x4bf6: 0x0100, 0x4bf7: 0x0100, 0x4bf8: 0x0100, 0x4bf9: 0x0100, 0x4bfa: 0x0100, 0x4bfb: 0x0100, // Block 0x130, offset 0x4c00 0x4c00: 0x0100, 0x4c01: 0x0100, 0x4c02: 0x0100, 0x4c03: 0x0100, 0x4c04: 0x0100, 0x4c05: 0x0100, 0x4c06: 0x0100, 0x4c07: 0x0100, 0x4c08: 0x0100, 0x4c09: 0x0100, 0x4c0a: 0x0100, 0x4c0b: 0x0100, 0x4c0c: 0x0100, 0x4c0d: 0x0100, 0x4c0e: 0x0100, 0x4c0f: 0x0100, 0x4c10: 0x0100, 0x4c11: 0x0100, 0x4c12: 0x0100, 0x4c13: 0x0100, 0x4c14: 0x0100, 0x4c15: 0x0100, 0x4c16: 0x0100, 0x4c17: 0x0100, 0x4c18: 0x0100, 0x4c19: 0x0100, 0x4c1a: 0x0100, 0x4c1b: 0x0100, 0x4c1c: 0x0100, 0x4c1d: 0x0100, 0x4c1e: 0x0100, 0x4c1f: 0x0100, 0x4c20: 0x0100, 0x4c21: 0x0100, 0x4c22: 0x0100, 0x4c23: 0x0100, 0x4c24: 0x0100, 0x4c25: 0x0100, 0x4c26: 0x0100, 0x4c27: 0x0100, 0x4c28: 0x0100, 0x4c29: 0x0100, 0x4c2a: 0x0100, 0x4c30: 0x0100, 0x4c31: 0x0100, 0x4c32: 0x0100, 0x4c33: 0x0100, 0x4c34: 0x0100, 0x4c35: 0x0100, 0x4c36: 0x0100, 0x4c37: 0x0100, 0x4c38: 0x0100, 0x4c39: 0x0100, 0x4c3a: 0x0100, 0x4c3b: 0x0100, 0x4c3c: 0x0100, // Block 0x131, offset 0x4c40 0x4c40: 0x0100, 0x4c41: 0x0100, 0x4c42: 0x0100, 0x4c43: 0x0100, 0x4c44: 0x0100, 0x4c45: 0x0100, 0x4c46: 0x0100, 0x4c47: 0x0100, 0x4c48: 0x0100, 0x4c50: 0x0100, 0x4c51: 0x0100, 0x4c52: 0x0100, 0x4c53: 0x0100, 0x4c54: 0x0100, 0x4c55: 0x0100, 0x4c56: 0x0100, 0x4c57: 0x0100, 0x4c58: 0x0100, 0x4c59: 0x0100, 0x4c5d: 0x0008, 0x4c5e: 0x0008, 0x4c5f: 0x0400, 0x4c60: 0x0010, 0x4c61: 0x0010, 0x4c62: 0x0010, 0x4c63: 0x0010, // Block 0x132, offset 0x4c80 0x4cb0: 0x0080, 0x4cb1: 0x0080, 0x4cb2: 0x0080, 0x4cb3: 0x0080, 0x4cb4: 0x0080, 0x4cb5: 0x0080, 0x4cb6: 0x0080, 0x4cb7: 0x0080, 0x4cb8: 0x0080, 0x4cb9: 0x0080, // Block 0x133, offset 0x4cc0 0x4cc0: 0x0008, 0x4cc1: 0x0008, 0x4cc2: 0x0008, 0x4cc3: 0x0008, 0x4cc4: 0x0008, 0x4cc5: 0x0008, 0x4cc6: 0x0008, 0x4cc7: 0x0008, 0x4cc8: 0x0008, 0x4cc9: 0x0008, 0x4cca: 0x0008, 0x4ccb: 0x0008, 0x4ccc: 0x0008, 0x4ccd: 0x0008, 0x4cce: 0x0008, 0x4ccf: 0x0008, 0x4cd0: 0x0008, 0x4cd1: 0x0008, 0x4cd2: 0x0008, 0x4cd3: 0x0008, 0x4cd4: 0x0008, 0x4cd5: 0x0008, 0x4cd6: 0x0008, 0x4cd7: 0x0008, 0x4cd8: 0x0008, 0x4cd9: 0x0008, 0x4cda: 0x0008, 0x4cdb: 0x0008, 0x4cdc: 0x0008, 0x4cdd: 0x0008, 0x4cde: 0x0008, 0x4cdf: 0x0008, 0x4ce0: 0x0008, 0x4ce1: 0x0008, 0x4ce2: 0x0008, 0x4ce3: 0x0008, 0x4ce4: 0x0008, 0x4ce5: 0x0008, 0x4ce6: 0x0008, 0x4ce7: 0x0008, 0x4ce8: 0x0008, 0x4ce9: 0x0008, 0x4cea: 0x0008, 0x4ceb: 0x0008, 0x4cec: 0x0008, 0x4ced: 0x0008, 0x4cf0: 0x0008, 0x4cf1: 0x0008, 0x4cf2: 0x0008, 0x4cf3: 0x0008, 0x4cf4: 0x0008, 0x4cf5: 0x0008, 0x4cf6: 0x0008, 0x4cf7: 0x0008, 0x4cf8: 0x0008, 0x4cf9: 0x0008, 0x4cfa: 0x0008, 0x4cfb: 0x0008, 0x4cfc: 0x0008, 0x4cfd: 0x0008, 0x4cfe: 0x0008, 0x4cff: 0x0008, // Block 0x134, offset 0x4d00 0x4d00: 0x0008, 0x4d01: 0x0008, 0x4d02: 0x0008, 0x4d03: 0x0008, 0x4d04: 0x0008, 0x4d05: 0x0008, 0x4d06: 0x0008, // Block 0x135, offset 0x4d40 0x4d65: 0x0008, 0x4d66: 0x0008, 0x4d67: 0x0008, 0x4d68: 0x0008, 0x4d69: 0x0008, 0x4d6d: 0x0008, 0x4d6e: 0x0008, 0x4d6f: 0x0008, 0x4d70: 0x0008, 0x4d71: 0x0008, 0x4d72: 0x0008, 0x4d73: 0x0010, 0x4d74: 0x0010, 0x4d75: 0x0010, 0x4d76: 0x0010, 0x4d77: 0x0010, 0x4d78: 0x0010, 0x4d79: 0x0010, 0x4d7a: 0x0010, 0x4d7b: 0x0008, 0x4d7c: 0x0008, 0x4d7d: 0x0008, 0x4d7e: 0x0008, 0x4d7f: 0x0008, // Block 0x136, offset 0x4d80 0x4d80: 0x0008, 0x4d81: 0x0008, 0x4d82: 0x0008, 0x4d85: 0x0008, 0x4d86: 0x0008, 0x4d87: 0x0008, 0x4d88: 0x0008, 0x4d89: 0x0008, 0x4d8a: 0x0008, 0x4d8b: 0x0008, 0x4daa: 0x0008, 0x4dab: 0x0008, 0x4dac: 0x0008, 0x4dad: 0x0008, // Block 0x137, offset 0x4dc0 0x4dc2: 0x0008, 0x4dc3: 0x0008, 0x4dc4: 0x0008, // Block 0x138, offset 0x4e00 0x4e00: 0x2000, 0x4e01: 0x2000, 0x4e02: 0x2000, 0x4e03: 0x2000, 0x4e04: 0x2000, 0x4e05: 0x2000, 0x4e06: 0x2000, 0x4e07: 0x2000, 0x4e08: 0x2000, 0x4e09: 0x2000, 0x4e0a: 0x2000, 0x4e0b: 0x2000, 0x4e0c: 0x2000, 0x4e0d: 0x2000, 0x4e0e: 0x2000, 0x4e0f: 0x2000, 0x4e10: 0x2000, 0x4e11: 0x2000, 0x4e12: 0x2000, 0x4e13: 0x2000, 0x4e14: 0x2000, 0x4e15: 0x2000, 0x4e16: 0x2000, 0x4e17: 0x2000, 0x4e18: 0x2000, 0x4e19: 0x2000, 0x4e1a: 0x0040, 0x4e1b: 0x0040, 0x4e1c: 0x0040, 0x4e1d: 0x0040, 0x4e1e: 0x0040, 0x4e1f: 0x0040, 0x4e20: 0x0040, 0x4e21: 0x0040, 0x4e22: 0x0040, 0x4e23: 0x0040, 0x4e24: 0x0040, 0x4e25: 0x0040, 0x4e26: 0x0040, 0x4e27: 0x0040, 0x4e28: 0x0040, 0x4e29: 0x0040, 0x4e2a: 0x0040, 0x4e2b: 0x0040, 0x4e2c: 0x0040, 0x4e2d: 0x0040, 0x4e2e: 0x0040, 0x4e2f: 0x0040, 0x4e30: 0x0040, 0x4e31: 0x0040, 0x4e32: 0x0040, 0x4e33: 0x0040, 0x4e34: 0x2000, 0x4e35: 0x2000, 0x4e36: 0x2000, 0x4e37: 0x2000, 0x4e38: 0x2000, 0x4e39: 0x2000, 0x4e3a: 0x2000, 0x4e3b: 0x2000, 0x4e3c: 0x2000, 0x4e3d: 0x2000, 0x4e3e: 0x2000, 0x4e3f: 0x2000, // Block 0x139, offset 0x4e40 0x4e40: 0x2000, 0x4e41: 0x2000, 0x4e42: 0x2000, 0x4e43: 0x2000, 0x4e44: 0x2000, 0x4e45: 0x2000, 0x4e46: 0x2000, 0x4e47: 0x2000, 0x4e48: 0x2000, 0x4e49: 0x2000, 0x4e4a: 0x2000, 0x4e4b: 0x2000, 0x4e4c: 0x2000, 0x4e4d: 0x2000, 0x4e4e: 0x0040, 0x4e4f: 0x0040, 0x4e50: 0x0040, 0x4e51: 0x0040, 0x4e52: 0x0040, 0x4e53: 0x0040, 0x4e54: 0x0040, 0x4e56: 0x0040, 0x4e57: 0x0040, 0x4e58: 0x0040, 0x4e59: 0x0040, 0x4e5a: 0x0040, 0x4e5b: 0x0040, 0x4e5c: 0x0040, 0x4e5d: 0x0040, 0x4e5e: 0x0040, 0x4e5f: 0x0040, 0x4e60: 0x0040, 0x4e61: 0x0040, 0x4e62: 0x0040, 0x4e63: 0x0040, 0x4e64: 0x0040, 0x4e65: 0x0040, 0x4e66: 0x0040, 0x4e67: 0x0040, 0x4e68: 0x2000, 0x4e69: 0x2000, 0x4e6a: 0x2000, 0x4e6b: 0x2000, 0x4e6c: 0x2000, 0x4e6d: 0x2000, 0x4e6e: 0x2000, 0x4e6f: 0x2000, 0x4e70: 0x2000, 0x4e71: 0x2000, 0x4e72: 0x2000, 0x4e73: 0x2000, 0x4e74: 0x2000, 0x4e75: 0x2000, 0x4e76: 0x2000, 0x4e77: 0x2000, 0x4e78: 0x2000, 0x4e79: 0x2000, 0x4e7a: 0x2000, 0x4e7b: 0x2000, 0x4e7c: 0x2000, 0x4e7d: 0x2000, 0x4e7e: 0x2000, 0x4e7f: 0x2000, // Block 0x13a, offset 0x4e80 0x4e80: 0x2000, 0x4e81: 0x2000, 0x4e82: 0x0040, 0x4e83: 0x0040, 0x4e84: 0x0040, 0x4e85: 0x0040, 0x4e86: 0x0040, 0x4e87: 0x0040, 0x4e88: 0x0040, 0x4e89: 0x0040, 0x4e8a: 0x0040, 0x4e8b: 0x0040, 0x4e8c: 0x0040, 0x4e8d: 0x0040, 0x4e8e: 0x0040, 0x4e8f: 0x0040, 0x4e90: 0x0040, 0x4e91: 0x0040, 0x4e92: 0x0040, 0x4e93: 0x0040, 0x4e94: 0x0040, 0x4e95: 0x0040, 0x4e96: 0x0040, 0x4e97: 0x0040, 0x4e98: 0x0040, 0x4e99: 0x0040, 0x4e9a: 0x0040, 0x4e9b: 0x0040, 0x4e9c: 0x2000, 0x4e9e: 0x2000, 0x4e9f: 0x2000, 0x4ea2: 0x2000, 0x4ea5: 0x2000, 0x4ea6: 0x2000, 0x4ea9: 0x2000, 0x4eaa: 0x2000, 0x4eab: 0x2000, 0x4eac: 0x2000, 0x4eae: 0x2000, 0x4eaf: 0x2000, 0x4eb0: 0x2000, 0x4eb1: 0x2000, 0x4eb2: 0x2000, 0x4eb3: 0x2000, 0x4eb4: 0x2000, 0x4eb5: 0x2000, 0x4eb6: 0x0040, 0x4eb7: 0x0040, 0x4eb8: 0x0040, 0x4eb9: 0x0040, 0x4ebb: 0x0040, 0x4ebd: 0x0040, 0x4ebe: 0x0040, 0x4ebf: 0x0040, // Block 0x13b, offset 0x4ec0 0x4ec0: 0x0040, 0x4ec1: 0x0040, 0x4ec2: 0x0040, 0x4ec3: 0x0040, 0x4ec5: 0x0040, 0x4ec6: 0x0040, 0x4ec7: 0x0040, 0x4ec8: 0x0040, 0x4ec9: 0x0040, 0x4eca: 0x0040, 0x4ecb: 0x0040, 0x4ecc: 0x0040, 0x4ecd: 0x0040, 0x4ece: 0x0040, 0x4ecf: 0x0040, 0x4ed0: 0x2000, 0x4ed1: 0x2000, 0x4ed2: 0x2000, 0x4ed3: 0x2000, 0x4ed4: 0x2000, 0x4ed5: 0x2000, 0x4ed6: 0x2000, 0x4ed7: 0x2000, 0x4ed8: 0x2000, 0x4ed9: 0x2000, 0x4eda: 0x2000, 0x4edb: 0x2000, 0x4edc: 0x2000, 0x4edd: 0x2000, 0x4ede: 0x2000, 0x4edf: 0x2000, 0x4ee0: 0x2000, 0x4ee1: 0x2000, 0x4ee2: 0x2000, 0x4ee3: 0x2000, 0x4ee4: 0x2000, 0x4ee5: 0x2000, 0x4ee6: 0x2000, 0x4ee7: 0x2000, 0x4ee8: 0x2000, 0x4ee9: 0x2000, 0x4eea: 0x0040, 0x4eeb: 0x0040, 0x4eec: 0x0040, 0x4eed: 0x0040, 0x4eee: 0x0040, 0x4eef: 0x0040, 0x4ef0: 0x0040, 0x4ef1: 0x0040, 0x4ef2: 0x0040, 0x4ef3: 0x0040, 0x4ef4: 0x0040, 0x4ef5: 0x0040, 0x4ef6: 0x0040, 0x4ef7: 0x0040, 0x4ef8: 0x0040, 0x4ef9: 0x0040, 0x4efa: 0x0040, 0x4efb: 0x0040, 0x4efc: 0x0040, 0x4efd: 0x0040, 0x4efe: 0x0040, 0x4eff: 0x0040, // Block 0x13c, offset 0x4f00 0x4f00: 0x0040, 0x4f01: 0x0040, 0x4f02: 0x0040, 0x4f03: 0x0040, 0x4f04: 0x2000, 0x4f05: 0x2000, 0x4f07: 0x2000, 0x4f08: 0x2000, 0x4f09: 0x2000, 0x4f0a: 0x2000, 0x4f0d: 0x2000, 0x4f0e: 0x2000, 0x4f0f: 0x2000, 0x4f10: 0x2000, 0x4f11: 0x2000, 0x4f12: 0x2000, 0x4f13: 0x2000, 0x4f14: 0x2000, 0x4f16: 0x2000, 0x4f17: 0x2000, 0x4f18: 0x2000, 0x4f19: 0x2000, 0x4f1a: 0x2000, 0x4f1b: 0x2000, 0x4f1c: 0x2000, 0x4f1e: 0x0040, 0x4f1f: 0x0040, 0x4f20: 0x0040, 0x4f21: 0x0040, 0x4f22: 0x0040, 0x4f23: 0x0040, 0x4f24: 0x0040, 0x4f25: 0x0040, 0x4f26: 0x0040, 0x4f27: 0x0040, 0x4f28: 0x0040, 0x4f29: 0x0040, 0x4f2a: 0x0040, 0x4f2b: 0x0040, 0x4f2c: 0x0040, 0x4f2d: 0x0040, 0x4f2e: 0x0040, 0x4f2f: 0x0040, 0x4f30: 0x0040, 0x4f31: 0x0040, 0x4f32: 0x0040, 0x4f33: 0x0040, 0x4f34: 0x0040, 0x4f35: 0x0040, 0x4f36: 0x0040, 0x4f37: 0x0040, 0x4f38: 0x2000, 0x4f39: 0x2000, 0x4f3b: 0x2000, 0x4f3c: 0x2000, 0x4f3d: 0x2000, 0x4f3e: 0x2000, // Block 0x13d, offset 0x4f40 0x4f40: 0x2000, 0x4f41: 0x2000, 0x4f42: 0x2000, 0x4f43: 0x2000, 0x4f44: 0x2000, 0x4f46: 0x2000, 0x4f4a: 0x2000, 0x4f4b: 0x2000, 0x4f4c: 0x2000, 0x4f4d: 0x2000, 0x4f4e: 0x2000, 0x4f4f: 0x2000, 0x4f50: 0x2000, 0x4f52: 0x0040, 0x4f53: 0x0040, 0x4f54: 0x0040, 0x4f55: 0x0040, 0x4f56: 0x0040, 0x4f57: 0x0040, 0x4f58: 0x0040, 0x4f59: 0x0040, 0x4f5a: 0x0040, 0x4f5b: 0x0040, 0x4f5c: 0x0040, 0x4f5d: 0x0040, 0x4f5e: 0x0040, 0x4f5f: 0x0040, 0x4f60: 0x0040, 0x4f61: 0x0040, 0x4f62: 0x0040, 0x4f63: 0x0040, 0x4f64: 0x0040, 0x4f65: 0x0040, 0x4f66: 0x0040, 0x4f67: 0x0040, 0x4f68: 0x0040, 0x4f69: 0x0040, 0x4f6a: 0x0040, 0x4f6b: 0x0040, 0x4f6c: 0x2000, 0x4f6d: 0x2000, 0x4f6e: 0x2000, 0x4f6f: 0x2000, 0x4f70: 0x2000, 0x4f71: 0x2000, 0x4f72: 0x2000, 0x4f73: 0x2000, 0x4f74: 0x2000, 0x4f75: 0x2000, 0x4f76: 0x2000, 0x4f77: 0x2000, 0x4f78: 0x2000, 0x4f79: 0x2000, 0x4f7a: 0x2000, 0x4f7b: 0x2000, 0x4f7c: 0x2000, 0x4f7d: 0x2000, 0x4f7e: 0x2000, 0x4f7f: 0x2000, // Block 0x13e, offset 0x4f80 0x4f80: 0x2000, 0x4f81: 0x2000, 0x4f82: 0x2000, 0x4f83: 0x2000, 0x4f84: 0x2000, 0x4f85: 0x2000, 0x4f86: 0x0040, 0x4f87: 0x0040, 0x4f88: 0x0040, 0x4f89: 0x0040, 0x4f8a: 0x0040, 0x4f8b: 0x0040, 0x4f8c: 0x0040, 0x4f8d: 0x0040, 0x4f8e: 0x0040, 0x4f8f: 0x0040, 0x4f90: 0x0040, 0x4f91: 0x0040, 0x4f92: 0x0040, 0x4f93: 0x0040, 0x4f94: 0x0040, 0x4f95: 0x0040, 0x4f96: 0x0040, 0x4f97: 0x0040, 0x4f98: 0x0040, 0x4f99: 0x0040, 0x4f9a: 0x0040, 0x4f9b: 0x0040, 0x4f9c: 0x0040, 0x4f9d: 0x0040, 0x4f9e: 0x0040, 0x4f9f: 0x0040, 0x4fa0: 0x2000, 0x4fa1: 0x2000, 0x4fa2: 0x2000, 0x4fa3: 0x2000, 0x4fa4: 0x2000, 0x4fa5: 0x2000, 0x4fa6: 0x2000, 0x4fa7: 0x2000, 0x4fa8: 0x2000, 0x4fa9: 0x2000, 0x4faa: 0x2000, 0x4fab: 0x2000, 0x4fac: 0x2000, 0x4fad: 0x2000, 0x4fae: 0x2000, 0x4faf: 0x2000, 0x4fb0: 0x2000, 0x4fb1: 0x2000, 0x4fb2: 0x2000, 0x4fb3: 0x2000, 0x4fb4: 0x2000, 0x4fb5: 0x2000, 0x4fb6: 0x2000, 0x4fb7: 0x2000, 0x4fb8: 0x2000, 0x4fb9: 0x2000, 0x4fba: 0x0040, 0x4fbb: 0x0040, 0x4fbc: 0x0040, 0x4fbd: 0x0040, 0x4fbe: 0x0040, 0x4fbf: 0x0040, // Block 0x13f, offset 0x4fc0 0x4fc0: 0x0040, 0x4fc1: 0x0040, 0x4fc2: 0x0040, 0x4fc3: 0x0040, 0x4fc4: 0x0040, 0x4fc5: 0x0040, 0x4fc6: 0x0040, 0x4fc7: 0x0040, 0x4fc8: 0x0040, 0x4fc9: 0x0040, 0x4fca: 0x0040, 0x4fcb: 0x0040, 0x4fcc: 0x0040, 0x4fcd: 0x0040, 0x4fce: 0x0040, 0x4fcf: 0x0040, 0x4fd0: 0x0040, 0x4fd1: 0x0040, 0x4fd2: 0x0040, 0x4fd3: 0x0040, 0x4fd4: 0x2000, 0x4fd5: 0x2000, 0x4fd6: 0x2000, 0x4fd7: 0x2000, 0x4fd8: 0x2000, 0x4fd9: 0x2000, 0x4fda: 0x2000, 0x4fdb: 0x2000, 0x4fdc: 0x2000, 0x4fdd: 0x2000, 0x4fde: 0x2000, 0x4fdf: 0x2000, 0x4fe0: 0x2000, 0x4fe1: 0x2000, 0x4fe2: 0x2000, 0x4fe3: 0x2000, 0x4fe4: 0x2000, 0x4fe5: 0x2000, 0x4fe6: 0x2000, 0x4fe7: 0x2000, 0x4fe8: 0x2000, 0x4fe9: 0x2000, 0x4fea: 0x2000, 0x4feb: 0x2000, 0x4fec: 0x2000, 0x4fed: 0x2000, 0x4fee: 0x0040, 0x4fef: 0x0040, 0x4ff0: 0x0040, 0x4ff1: 0x0040, 0x4ff2: 0x0040, 0x4ff3: 0x0040, 0x4ff4: 0x0040, 0x4ff5: 0x0040, 0x4ff6: 0x0040, 0x4ff7: 0x0040, 0x4ff8: 0x0040, 0x4ff9: 0x0040, 0x4ffa: 0x0040, 0x4ffb: 0x0040, 0x4ffc: 0x0040, 0x4ffd: 0x0040, 0x4ffe: 0x0040, 0x4fff: 0x0040, // Block 0x140, offset 0x5000 0x5000: 0x0040, 0x5001: 0x0040, 0x5002: 0x0040, 0x5003: 0x0040, 0x5004: 0x0040, 0x5005: 0x0040, 0x5006: 0x0040, 0x5007: 0x0040, 0x5008: 0x2000, 0x5009: 0x2000, 0x500a: 0x2000, 0x500b: 0x2000, 0x500c: 0x2000, 0x500d: 0x2000, 0x500e: 0x2000, 0x500f: 0x2000, 0x5010: 0x2000, 0x5011: 0x2000, 0x5012: 0x2000, 0x5013: 0x2000, 0x5014: 0x2000, 0x5015: 0x2000, 0x5016: 0x2000, 0x5017: 0x2000, 0x5018: 0x2000, 0x5019: 0x2000, 0x501a: 0x2000, 0x501b: 0x2000, 0x501c: 0x2000, 0x501d: 0x2000, 0x501e: 0x2000, 0x501f: 0x2000, 0x5020: 0x2000, 0x5021: 0x2000, 0x5022: 0x0040, 0x5023: 0x0040, 0x5024: 0x0040, 0x5025: 0x0040, 0x5026: 0x0040, 0x5027: 0x0040, 0x5028: 0x0040, 0x5029: 0x0040, 0x502a: 0x0040, 0x502b: 0x0040, 0x502c: 0x0040, 0x502d: 0x0040, 0x502e: 0x0040, 0x502f: 0x0040, 0x5030: 0x0040, 0x5031: 0x0040, 0x5032: 0x0040, 0x5033: 0x0040, 0x5034: 0x0040, 0x5035: 0x0040, 0x5036: 0x0040, 0x5037: 0x0040, 0x5038: 0x0040, 0x5039: 0x0040, 0x503a: 0x0040, 0x503b: 0x0040, 0x503c: 0x2000, 0x503d: 0x2000, 0x503e: 0x2000, 0x503f: 0x2000, // Block 0x141, offset 0x5040 0x5040: 0x2000, 0x5041: 0x2000, 0x5042: 0x2000, 0x5043: 0x2000, 0x5044: 0x2000, 0x5045: 0x2000, 0x5046: 0x2000, 0x5047: 0x2000, 0x5048: 0x2000, 0x5049: 0x2000, 0x504a: 0x2000, 0x504b: 0x2000, 0x504c: 0x2000, 0x504d: 0x2000, 0x504e: 0x2000, 0x504f: 0x2000, 0x5050: 0x2000, 0x5051: 0x2000, 0x5052: 0x2000, 0x5053: 0x2000, 0x5054: 0x2000, 0x5055: 0x2000, 0x5056: 0x0040, 0x5057: 0x0040, 0x5058: 0x0040, 0x5059: 0x0040, 0x505a: 0x0040, 0x505b: 0x0040, 0x505c: 0x0040, 0x505d: 0x0040, 0x505e: 0x0040, 0x505f: 0x0040, 0x5060: 0x0040, 0x5061: 0x0040, 0x5062: 0x0040, 0x5063: 0x0040, 0x5064: 0x0040, 0x5065: 0x0040, 0x5066: 0x0040, 0x5067: 0x0040, 0x5068: 0x0040, 0x5069: 0x0040, 0x506a: 0x0040, 0x506b: 0x0040, 0x506c: 0x0040, 0x506d: 0x0040, 0x506e: 0x0040, 0x506f: 0x0040, 0x5070: 0x2000, 0x5071: 0x2000, 0x5072: 0x2000, 0x5073: 0x2000, 0x5074: 0x2000, 0x5075: 0x2000, 0x5076: 0x2000, 0x5077: 0x2000, 0x5078: 0x2000, 0x5079: 0x2000, 0x507a: 0x2000, 0x507b: 0x2000, 0x507c: 0x2000, 0x507d: 0x2000, 0x507e: 0x2000, 0x507f: 0x2000, // Block 0x142, offset 0x5080 0x5080: 0x2000, 0x5081: 0x2000, 0x5082: 0x2000, 0x5083: 0x2000, 0x5084: 0x2000, 0x5085: 0x2000, 0x5086: 0x2000, 0x5087: 0x2000, 0x5088: 0x2000, 0x5089: 0x2000, 0x508a: 0x0040, 0x508b: 0x0040, 0x508c: 0x0040, 0x508d: 0x0040, 0x508e: 0x0040, 0x508f: 0x0040, 0x5090: 0x0040, 0x5091: 0x0040, 0x5092: 0x0040, 0x5093: 0x0040, 0x5094: 0x0040, 0x5095: 0x0040, 0x5096: 0x0040, 0x5097: 0x0040, 0x5098: 0x0040, 0x5099: 0x0040, 0x509a: 0x0040, 0x509b: 0x0040, 0x509c: 0x0040, 0x509d: 0x0040, 0x509e: 0x0040, 0x509f: 0x0040, 0x50a0: 0x0040, 0x50a1: 0x0040, 0x50a2: 0x0040, 0x50a3: 0x0040, 0x50a4: 0x0040, 0x50a5: 0x0040, 0x50a8: 0x2000, 0x50a9: 0x2000, 0x50aa: 0x2000, 0x50ab: 0x2000, 0x50ac: 0x2000, 0x50ad: 0x2000, 0x50ae: 0x2000, 0x50af: 0x2000, 0x50b0: 0x2000, 0x50b1: 0x2000, 0x50b2: 0x2000, 0x50b3: 0x2000, 0x50b4: 0x2000, 0x50b5: 0x2000, 0x50b6: 0x2000, 0x50b7: 0x2000, 0x50b8: 0x2000, 0x50b9: 0x2000, 0x50ba: 0x2000, 0x50bb: 0x2000, 0x50bc: 0x2000, 0x50bd: 0x2000, 0x50be: 0x2000, 0x50bf: 0x2000, // Block 0x143, offset 0x50c0 0x50c0: 0x2000, 0x50c2: 0x0040, 0x50c3: 0x0040, 0x50c4: 0x0040, 0x50c5: 0x0040, 0x50c6: 0x0040, 0x50c7: 0x0040, 0x50c8: 0x0040, 0x50c9: 0x0040, 0x50ca: 0x0040, 0x50cb: 0x0040, 0x50cc: 0x0040, 0x50cd: 0x0040, 0x50ce: 0x0040, 0x50cf: 0x0040, 0x50d0: 0x0040, 0x50d1: 0x0040, 0x50d2: 0x0040, 0x50d3: 0x0040, 0x50d4: 0x0040, 0x50d5: 0x0040, 0x50d6: 0x0040, 0x50d7: 0x0040, 0x50d8: 0x0040, 0x50d9: 0x0040, 0x50da: 0x0040, 0x50dc: 0x0040, 0x50dd: 0x0040, 0x50de: 0x0040, 0x50df: 0x0040, 0x50e0: 0x0040, 0x50e1: 0x0040, 0x50e2: 0x2000, 0x50e3: 0x2000, 0x50e4: 0x2000, 0x50e5: 0x2000, 0x50e6: 0x2000, 0x50e7: 0x2000, 0x50e8: 0x2000, 0x50e9: 0x2000, 0x50ea: 0x2000, 0x50eb: 0x2000, 0x50ec: 0x2000, 0x50ed: 0x2000, 0x50ee: 0x2000, 0x50ef: 0x2000, 0x50f0: 0x2000, 0x50f1: 0x2000, 0x50f2: 0x2000, 0x50f3: 0x2000, 0x50f4: 0x2000, 0x50f5: 0x2000, 0x50f6: 0x2000, 0x50f7: 0x2000, 0x50f8: 0x2000, 0x50f9: 0x2000, 0x50fa: 0x2000, 0x50fc: 0x0040, 0x50fd: 0x0040, 0x50fe: 0x0040, 0x50ff: 0x0040, // Block 0x144, offset 0x5100 0x5100: 0x0040, 0x5101: 0x0040, 0x5102: 0x0040, 0x5103: 0x0040, 0x5104: 0x0040, 0x5105: 0x0040, 0x5106: 0x0040, 0x5107: 0x0040, 0x5108: 0x0040, 0x5109: 0x0040, 0x510a: 0x0040, 0x510b: 0x0040, 0x510c: 0x0040, 0x510d: 0x0040, 0x510e: 0x0040, 0x510f: 0x0040, 0x5110: 0x0040, 0x5111: 0x0040, 0x5112: 0x0040, 0x5113: 0x0040, 0x5114: 0x0040, 0x5116: 0x0040, 0x5117: 0x0040, 0x5118: 0x0040, 0x5119: 0x0040, 0x511a: 0x0040, 0x511b: 0x0040, 0x511c: 0x2000, 0x511d: 0x2000, 0x511e: 0x2000, 0x511f: 0x2000, 0x5120: 0x2000, 0x5121: 0x2000, 0x5122: 0x2000, 0x5123: 0x2000, 0x5124: 0x2000, 0x5125: 0x2000, 0x5126: 0x2000, 0x5127: 0x2000, 0x5128: 0x2000, 0x5129: 0x2000, 0x512a: 0x2000, 0x512b: 0x2000, 0x512c: 0x2000, 0x512d: 0x2000, 0x512e: 0x2000, 0x512f: 0x2000, 0x5130: 0x2000, 0x5131: 0x2000, 0x5132: 0x2000, 0x5133: 0x2000, 0x5134: 0x2000, 0x5136: 0x0040, 0x5137: 0x0040, 0x5138: 0x0040, 0x5139: 0x0040, 0x513a: 0x0040, 0x513b: 0x0040, 0x513c: 0x0040, 0x513d: 0x0040, 0x513e: 0x0040, 0x513f: 0x0040, // Block 0x145, offset 0x5140 0x5140: 0x0040, 0x5141: 0x0040, 0x5142: 0x0040, 0x5143: 0x0040, 0x5144: 0x0040, 0x5145: 0x0040, 0x5146: 0x0040, 0x5147: 0x0040, 0x5148: 0x0040, 0x5149: 0x0040, 0x514a: 0x0040, 0x514b: 0x0040, 0x514c: 0x0040, 0x514d: 0x0040, 0x514e: 0x0040, 0x5150: 0x0040, 0x5151: 0x0040, 0x5152: 0x0040, 0x5153: 0x0040, 0x5154: 0x0040, 0x5155: 0x0040, 0x5156: 0x2000, 0x5157: 0x2000, 0x5158: 0x2000, 0x5159: 0x2000, 0x515a: 0x2000, 0x515b: 0x2000, 0x515c: 0x2000, 0x515d: 0x2000, 0x515e: 0x2000, 0x515f: 0x2000, 0x5160: 0x2000, 0x5161: 0x2000, 0x5162: 0x2000, 0x5163: 0x2000, 0x5164: 0x2000, 0x5165: 0x2000, 0x5166: 0x2000, 0x5167: 0x2000, 0x5168: 0x2000, 0x5169: 0x2000, 0x516a: 0x2000, 0x516b: 0x2000, 0x516c: 0x2000, 0x516d: 0x2000, 0x516e: 0x2000, 0x5170: 0x0040, 0x5171: 0x0040, 0x5172: 0x0040, 0x5173: 0x0040, 0x5174: 0x0040, 0x5175: 0x0040, 0x5176: 0x0040, 0x5177: 0x0040, 0x5178: 0x0040, 0x5179: 0x0040, 0x517a: 0x0040, 0x517b: 0x0040, 0x517c: 0x0040, 0x517d: 0x0040, 0x517e: 0x0040, 0x517f: 0x0040, // Block 0x146, offset 0x5180 0x5180: 0x0040, 0x5181: 0x0040, 0x5182: 0x0040, 0x5183: 0x0040, 0x5184: 0x0040, 0x5185: 0x0040, 0x5186: 0x0040, 0x5187: 0x0040, 0x5188: 0x0040, 0x518a: 0x0040, 0x518b: 0x0040, 0x518c: 0x0040, 0x518d: 0x0040, 0x518e: 0x0040, 0x518f: 0x0040, 0x5190: 0x2000, 0x5191: 0x2000, 0x5192: 0x2000, 0x5193: 0x2000, 0x5194: 0x2000, 0x5195: 0x2000, 0x5196: 0x2000, 0x5197: 0x2000, 0x5198: 0x2000, 0x5199: 0x2000, 0x519a: 0x2000, 0x519b: 0x2000, 0x519c: 0x2000, 0x519d: 0x2000, 0x519e: 0x2000, 0x519f: 0x2000, 0x51a0: 0x2000, 0x51a1: 0x2000, 0x51a2: 0x2000, 0x51a3: 0x2000, 0x51a4: 0x2000, 0x51a5: 0x2000, 0x51a6: 0x2000, 0x51a7: 0x2000, 0x51a8: 0x2000, 0x51aa: 0x0040, 0x51ab: 0x0040, 0x51ac: 0x0040, 0x51ad: 0x0040, 0x51ae: 0x0040, 0x51af: 0x0040, 0x51b0: 0x0040, 0x51b1: 0x0040, 0x51b2: 0x0040, 0x51b3: 0x0040, 0x51b4: 0x0040, 0x51b5: 0x0040, 0x51b6: 0x0040, 0x51b7: 0x0040, 0x51b8: 0x0040, 0x51b9: 0x0040, 0x51ba: 0x0040, 0x51bb: 0x0040, 0x51bc: 0x0040, 0x51bd: 0x0040, 0x51be: 0x0040, 0x51bf: 0x0040, // Block 0x147, offset 0x51c0 0x51c0: 0x0040, 0x51c1: 0x0040, 0x51c2: 0x0040, 0x51c4: 0x0040, 0x51c5: 0x0040, 0x51c6: 0x0040, 0x51c7: 0x0040, 0x51c8: 0x0040, 0x51c9: 0x0040, 0x51ca: 0x2000, 0x51cb: 0x0040, 0x51ce: 0x0080, 0x51cf: 0x0080, 0x51d0: 0x0080, 0x51d1: 0x0080, 0x51d2: 0x0080, 0x51d3: 0x0080, 0x51d4: 0x0080, 0x51d5: 0x0080, 0x51d6: 0x0080, 0x51d7: 0x0080, 0x51d8: 0x0080, 0x51d9: 0x0080, 0x51da: 0x0080, 0x51db: 0x0080, 0x51dc: 0x0080, 0x51dd: 0x0080, 0x51de: 0x0080, 0x51df: 0x0080, 0x51e0: 0x0080, 0x51e1: 0x0080, 0x51e2: 0x0080, 0x51e3: 0x0080, 0x51e4: 0x0080, 0x51e5: 0x0080, 0x51e6: 0x0080, 0x51e7: 0x0080, 0x51e8: 0x0080, 0x51e9: 0x0080, 0x51ea: 0x0080, 0x51eb: 0x0080, 0x51ec: 0x0080, 0x51ed: 0x0080, 0x51ee: 0x0080, 0x51ef: 0x0080, 0x51f0: 0x0080, 0x51f1: 0x0080, 0x51f2: 0x0080, 0x51f3: 0x0080, 0x51f4: 0x0080, 0x51f5: 0x0080, 0x51f6: 0x0080, 0x51f7: 0x0080, 0x51f8: 0x0080, 0x51f9: 0x0080, 0x51fa: 0x0080, 0x51fb: 0x0080, 0x51fc: 0x0080, 0x51fd: 0x0080, 0x51fe: 0x0080, 0x51ff: 0x0080, // Block 0x148, offset 0x5200 0x5200: 0x0008, 0x5201: 0x0008, 0x5202: 0x0008, 0x5203: 0x0008, 0x5204: 0x0008, 0x5205: 0x0008, 0x5206: 0x0008, 0x5207: 0x0008, 0x5208: 0x0008, 0x5209: 0x0008, 0x520a: 0x0008, 0x520b: 0x0008, 0x520c: 0x0008, 0x520d: 0x0008, 0x520e: 0x0008, 0x520f: 0x0008, 0x5210: 0x0008, 0x5211: 0x0008, 0x5212: 0x0008, 0x5213: 0x0008, 0x5214: 0x0008, 0x5215: 0x0008, 0x5216: 0x0008, 0x5217: 0x0008, 0x5218: 0x0008, 0x5219: 0x0008, 0x521a: 0x0008, 0x521b: 0x0008, 0x521c: 0x0008, 0x521d: 0x0008, 0x521e: 0x0008, 0x521f: 0x0008, 0x5220: 0x0008, 0x5221: 0x0008, 0x5222: 0x0008, 0x5223: 0x0008, 0x5224: 0x0008, 0x5225: 0x0008, 0x5226: 0x0008, 0x5227: 0x0008, 0x5228: 0x0008, 0x5229: 0x0008, 0x522a: 0x0008, 0x522b: 0x0008, 0x522c: 0x0008, 0x522d: 0x0008, 0x522e: 0x0008, 0x522f: 0x0008, 0x5230: 0x0008, 0x5231: 0x0008, 0x5232: 0x0008, 0x5233: 0x0008, 0x5234: 0x0008, 0x5235: 0x0008, 0x5236: 0x0008, 0x523b: 0x0008, 0x523c: 0x0008, 0x523d: 0x0008, 0x523e: 0x0008, 0x523f: 0x0008, // Block 0x149, offset 0x5240 0x5240: 0x0008, 0x5241: 0x0008, 0x5242: 0x0008, 0x5243: 0x0008, 0x5244: 0x0008, 0x5245: 0x0008, 0x5246: 0x0008, 0x5247: 0x0008, 0x5248: 0x0008, 0x5249: 0x0008, 0x524a: 0x0008, 0x524b: 0x0008, 0x524c: 0x0008, 0x524d: 0x0008, 0x524e: 0x0008, 0x524f: 0x0008, 0x5250: 0x0008, 0x5251: 0x0008, 0x5252: 0x0008, 0x5253: 0x0008, 0x5254: 0x0008, 0x5255: 0x0008, 0x5256: 0x0008, 0x5257: 0x0008, 0x5258: 0x0008, 0x5259: 0x0008, 0x525a: 0x0008, 0x525b: 0x0008, 0x525c: 0x0008, 0x525d: 0x0008, 0x525e: 0x0008, 0x525f: 0x0008, 0x5260: 0x0008, 0x5261: 0x0008, 0x5262: 0x0008, 0x5263: 0x0008, 0x5264: 0x0008, 0x5265: 0x0008, 0x5266: 0x0008, 0x5267: 0x0008, 0x5268: 0x0008, 0x5269: 0x0008, 0x526a: 0x0008, 0x526b: 0x0008, 0x526c: 0x0008, 0x5275: 0x0008, // Block 0x14a, offset 0x5280 0x5284: 0x0008, 0x5288: 0x0400, 0x529b: 0x0008, 0x529c: 0x0008, 0x529d: 0x0008, 0x529e: 0x0008, 0x529f: 0x0008, 0x52a1: 0x0008, 0x52a2: 0x0008, 0x52a3: 0x0008, 0x52a4: 0x0008, 0x52a5: 0x0008, 0x52a6: 0x0008, 0x52a7: 0x0008, 0x52a8: 0x0008, 0x52a9: 0x0008, 0x52aa: 0x0008, 0x52ab: 0x0008, 0x52ac: 0x0008, 0x52ad: 0x0008, 0x52ae: 0x0008, 0x52af: 0x0008, // Block 0x14b, offset 0x52c0 0x52c0: 0x0040, 0x52c1: 0x0040, 0x52c2: 0x0040, 0x52c3: 0x0040, 0x52c4: 0x0040, 0x52c5: 0x0040, 0x52c6: 0x0040, 0x52c7: 0x0040, 0x52c8: 0x0040, 0x52c9: 0x0040, 0x52ca: 0x0100, 0x52cb: 0x0040, 0x52cc: 0x0040, 0x52cd: 0x0040, 0x52ce: 0x0040, 0x52cf: 0x0040, 0x52d0: 0x0040, 0x52d1: 0x0040, 0x52d2: 0x0040, 0x52d3: 0x0040, 0x52d4: 0x0040, 0x52d5: 0x0040, 0x52d6: 0x0040, 0x52d7: 0x0040, 0x52d8: 0x0040, 0x52d9: 0x0040, 0x52da: 0x0040, 0x52db: 0x0040, 0x52dc: 0x0040, 0x52dd: 0x0040, 0x52de: 0x0040, 0x52e5: 0x0040, 0x52e6: 0x0040, 0x52e7: 0x0040, 0x52e8: 0x0040, 0x52e9: 0x0040, 0x52ea: 0x0040, // Block 0x14c, offset 0x5300 0x5300: 0x0008, 0x5301: 0x0008, 0x5302: 0x0008, 0x5303: 0x0008, 0x5304: 0x0008, 0x5305: 0x0008, 0x5306: 0x0008, 0x5308: 0x0008, 0x5309: 0x0008, 0x530a: 0x0008, 0x530b: 0x0008, 0x530c: 0x0008, 0x530d: 0x0008, 0x530e: 0x0008, 0x530f: 0x0008, 0x5310: 0x0008, 0x5311: 0x0008, 0x5312: 0x0008, 0x5313: 0x0008, 0x5314: 0x0008, 0x5315: 0x0008, 0x5316: 0x0008, 0x5317: 0x0008, 0x5318: 0x0008, 0x531b: 0x0008, 0x531c: 0x0008, 0x531d: 0x0008, 0x531e: 0x0008, 0x531f: 0x0008, 0x5320: 0x0008, 0x5321: 0x0008, 0x5323: 0x0008, 0x5324: 0x0008, 0x5326: 0x0008, 0x5327: 0x0008, 0x5328: 0x0008, 0x5329: 0x0008, 0x532a: 0x0008, 0x5330: 0x0040, 0x5331: 0x0040, 0x5332: 0x0040, 0x5333: 0x0040, 0x5334: 0x0040, 0x5335: 0x0040, 0x5336: 0x0040, 0x5337: 0x0040, 0x5338: 0x0040, 0x5339: 0x0040, 0x533a: 0x0040, 0x533b: 0x0040, 0x533c: 0x0040, 0x533d: 0x0040, 0x533e: 0x0040, 0x533f: 0x0040, // Block 0x14d, offset 0x5340 0x5340: 0x0040, 0x5341: 0x0040, 0x5342: 0x0040, 0x5343: 0x0040, 0x5344: 0x0040, 0x5345: 0x0040, 0x5346: 0x0040, 0x5347: 0x0040, 0x5348: 0x0040, 0x5349: 0x0040, 0x534a: 0x0040, 0x534b: 0x0040, 0x534c: 0x0040, 0x534d: 0x0040, 0x534e: 0x0040, 0x534f: 0x0040, 0x5350: 0x0040, 0x5351: 0x0040, 0x5352: 0x0040, 0x5353: 0x0040, 0x5354: 0x0040, 0x5355: 0x0040, 0x5356: 0x0040, 0x5357: 0x0040, 0x5358: 0x0040, 0x5359: 0x0040, 0x535a: 0x0040, 0x535b: 0x0040, 0x535c: 0x0040, 0x535d: 0x0040, 0x535e: 0x0040, 0x535f: 0x0040, 0x5360: 0x0040, 0x5361: 0x0040, 0x5362: 0x0040, 0x5363: 0x0040, 0x5364: 0x0040, 0x5365: 0x0040, 0x5366: 0x0040, 0x5367: 0x0040, 0x5368: 0x0040, 0x5369: 0x0040, 0x536a: 0x0040, 0x536b: 0x0040, 0x536c: 0x0040, 0x536d: 0x0040, // Block 0x14e, offset 0x5380 0x538f: 0x0008, // Block 0x14f, offset 0x53c0 0x53c0: 0x0100, 0x53c1: 0x0100, 0x53c2: 0x0100, 0x53c3: 0x0100, 0x53c4: 0x0100, 0x53c5: 0x0100, 0x53c6: 0x0100, 0x53c7: 0x0100, 0x53c8: 0x0100, 0x53c9: 0x0100, 0x53ca: 0x0100, 0x53cb: 0x0100, 0x53cc: 0x0100, 0x53cd: 0x0100, 0x53ce: 0x0100, 0x53cf: 0x0100, 0x53d0: 0x0100, 0x53d1: 0x0100, 0x53d2: 0x0100, 0x53d3: 0x0100, 0x53d4: 0x0100, 0x53d5: 0x0100, 0x53d6: 0x0100, 0x53d7: 0x0100, 0x53d8: 0x0100, 0x53d9: 0x0100, 0x53da: 0x0100, 0x53db: 0x0100, 0x53dc: 0x0100, 0x53dd: 0x0100, 0x53de: 0x0100, 0x53df: 0x0100, 0x53e0: 0x0100, 0x53e1: 0x0100, 0x53e2: 0x0100, 0x53e3: 0x0100, 0x53e4: 0x0100, 0x53e5: 0x0100, 0x53e6: 0x0100, 0x53e7: 0x0100, 0x53e8: 0x0100, 0x53e9: 0x0100, 0x53ea: 0x0100, 0x53eb: 0x0100, 0x53ec: 0x0100, 0x53f0: 0x0008, 0x53f1: 0x0008, 0x53f2: 0x0008, 0x53f3: 0x0008, 0x53f4: 0x0008, 0x53f5: 0x0008, 0x53f6: 0x0008, 0x53f7: 0x0100, 0x53f8: 0x0100, 0x53f9: 0x0100, 0x53fa: 0x0100, 0x53fb: 0x0100, 0x53fc: 0x0100, 0x53fd: 0x0100, // Block 0x150, offset 0x5400 0x5400: 0x0080, 0x5401: 0x0080, 0x5402: 0x0080, 0x5403: 0x0080, 0x5404: 0x0080, 0x5405: 0x0080, 0x5406: 0x0080, 0x5407: 0x0080, 0x5408: 0x0080, 0x5409: 0x0080, 0x540e: 0x0100, // Block 0x151, offset 0x5440 0x5450: 0x0100, 0x5451: 0x0100, 0x5452: 0x0100, 0x5453: 0x0100, 0x5454: 0x0100, 0x5455: 0x0100, 0x5456: 0x0100, 0x5457: 0x0100, 0x5458: 0x0100, 0x5459: 0x0100, 0x545a: 0x0100, 0x545b: 0x0100, 0x545c: 0x0100, 0x545d: 0x0100, 0x545e: 0x0100, 0x545f: 0x0100, 0x5460: 0x0100, 0x5461: 0x0100, 0x5462: 0x0100, 0x5463: 0x0100, 0x5464: 0x0100, 0x5465: 0x0100, 0x5466: 0x0100, 0x5467: 0x0100, 0x5468: 0x0100, 0x5469: 0x0100, 0x546a: 0x0100, 0x546b: 0x0100, 0x546c: 0x0100, 0x546d: 0x0100, 0x546e: 0x0008, // Block 0x152, offset 0x5480 0x5480: 0x0100, 0x5481: 0x0100, 0x5482: 0x0100, 0x5483: 0x0100, 0x5484: 0x0100, 0x5485: 0x0100, 0x5486: 0x0100, 0x5487: 0x0100, 0x5488: 0x0100, 0x5489: 0x0100, 0x548a: 0x0100, 0x548b: 0x0100, 0x548c: 0x0100, 0x548d: 0x0100, 0x548e: 0x0100, 0x548f: 0x0100, 0x5490: 0x0100, 0x5491: 0x0100, 0x5492: 0x0100, 0x5493: 0x0100, 0x5494: 0x0100, 0x5495: 0x0100, 0x5496: 0x0100, 0x5497: 0x0100, 0x5498: 0x0100, 0x5499: 0x0100, 0x549a: 0x0100, 0x549b: 0x0100, 0x549c: 0x0100, 0x549d: 0x0100, 0x549e: 0x0100, 0x549f: 0x0100, 0x54a0: 0x0100, 0x54a1: 0x0100, 0x54a2: 0x0100, 0x54a3: 0x0100, 0x54a4: 0x0100, 0x54a5: 0x0100, 0x54a6: 0x0100, 0x54a7: 0x0100, 0x54a8: 0x0100, 0x54a9: 0x0100, 0x54aa: 0x0100, 0x54ab: 0x0100, 0x54ac: 0x0008, 0x54ad: 0x0008, 0x54ae: 0x0008, 0x54af: 0x0008, 0x54b0: 0x0080, 0x54b1: 0x0080, 0x54b2: 0x0080, 0x54b3: 0x0080, 0x54b4: 0x0080, 0x54b5: 0x0080, 0x54b6: 0x0080, 0x54b7: 0x0080, 0x54b8: 0x0080, 0x54b9: 0x0080, // Block 0x153, offset 0x54c0 0x54d0: 0x0100, 0x54d1: 0x0100, 0x54d2: 0x0100, 0x54d3: 0x0100, 0x54d4: 0x0100, 0x54d5: 0x0100, 0x54d6: 0x0100, 0x54d7: 0x0100, 0x54d8: 0x0100, 0x54d9: 0x0100, 0x54da: 0x0100, 0x54db: 0x0100, 0x54dc: 0x0100, 0x54dd: 0x0100, 0x54de: 0x0100, 0x54df: 0x0100, 0x54e0: 0x0100, 0x54e1: 0x0100, 0x54e2: 0x0100, 0x54e3: 0x0100, 0x54e4: 0x0100, 0x54e5: 0x0100, 0x54e6: 0x0100, 0x54e7: 0x0100, 0x54e8: 0x0100, 0x54e9: 0x0100, 0x54ea: 0x0100, 0x54eb: 0x0100, 0x54ec: 0x0008, 0x54ed: 0x0008, 0x54ee: 0x0008, 0x54ef: 0x0008, 0x54f0: 0x0080, 0x54f1: 0x0080, 0x54f2: 0x0080, 0x54f3: 0x0080, 0x54f4: 0x0080, 0x54f5: 0x0080, 0x54f6: 0x0080, 0x54f7: 0x0080, 0x54f8: 0x0080, 0x54f9: 0x0080, // Block 0x154, offset 0x5500 0x5510: 0x0100, 0x5511: 0x0100, 0x5512: 0x0100, 0x5513: 0x0100, 0x5514: 0x0100, 0x5515: 0x0100, 0x5516: 0x0100, 0x5517: 0x0100, 0x5518: 0x0100, 0x5519: 0x0100, 0x551a: 0x0100, 0x551b: 0x0100, 0x551c: 0x0100, 0x551d: 0x0100, 0x551e: 0x0100, 0x551f: 0x0100, 0x5520: 0x0100, 0x5521: 0x0100, 0x5522: 0x0100, 0x5523: 0x0100, 0x5524: 0x0100, 0x5525: 0x0100, 0x5526: 0x0100, 0x5527: 0x0100, 0x5528: 0x0100, 0x5529: 0x0100, 0x552a: 0x0100, 0x552b: 0x0100, 0x552c: 0x0100, 0x552d: 0x0100, 0x552e: 0x0008, 0x552f: 0x0008, 0x5530: 0x0100, 0x5531: 0x0080, 0x5532: 0x0080, 0x5533: 0x0080, 0x5534: 0x0080, 0x5535: 0x0080, 0x5536: 0x0080, 0x5537: 0x0080, 0x5538: 0x0080, 0x5539: 0x0080, 0x553a: 0x0080, // Block 0x155, offset 0x5540 0x5540: 0x0100, 0x5541: 0x0100, 0x5542: 0x0100, 0x5543: 0x0100, 0x5544: 0x0100, 0x5545: 0x0100, 0x5546: 0x0100, 0x5547: 0x0100, 0x5548: 0x0100, 0x5549: 0x0100, 0x554a: 0x0100, 0x554b: 0x0100, 0x554c: 0x0100, 0x554d: 0x0100, 0x554e: 0x0100, 0x554f: 0x0100, 0x5550: 0x0100, 0x5551: 0x0100, 0x5552: 0x0100, 0x5553: 0x0100, 0x5554: 0x0100, 0x5555: 0x0100, 0x5556: 0x0100, 0x5557: 0x0100, 0x5558: 0x0100, 0x5559: 0x0100, 0x555a: 0x0100, 0x555b: 0x0100, 0x555c: 0x0100, 0x555d: 0x0100, 0x555e: 0x0100, 0x5560: 0x0100, 0x5561: 0x0100, 0x5562: 0x0100, 0x5563: 0x0008, 0x5564: 0x0100, 0x5565: 0x0100, 0x5566: 0x0008, 0x5567: 0x0100, 0x5568: 0x0100, 0x5569: 0x0100, 0x556a: 0x0100, 0x556b: 0x0100, 0x556c: 0x0100, 0x556d: 0x0100, 0x556e: 0x0008, 0x556f: 0x0008, 0x5570: 0x0100, 0x5571: 0x0100, 0x5572: 0x0100, 0x5573: 0x0100, 0x5574: 0x0100, 0x5575: 0x0008, 0x557e: 0x0100, 0x557f: 0x0100, // Block 0x156, offset 0x5580 0x55a0: 0x0100, 0x55a1: 0x0100, 0x55a2: 0x0100, 0x55a3: 0x0100, 0x55a4: 0x0100, 0x55a5: 0x0100, 0x55a6: 0x0100, 0x55a8: 0x0100, 0x55a9: 0x0100, 0x55aa: 0x0100, 0x55ab: 0x0100, 0x55ad: 0x0100, 0x55ae: 0x0100, 0x55b0: 0x0100, 0x55b1: 0x0100, 0x55b2: 0x0100, 0x55b3: 0x0100, 0x55b4: 0x0100, 0x55b5: 0x0100, 0x55b6: 0x0100, 0x55b7: 0x0100, 0x55b8: 0x0100, 0x55b9: 0x0100, 0x55ba: 0x0100, 0x55bb: 0x0100, 0x55bc: 0x0100, 0x55bd: 0x0100, 0x55be: 0x0100, // Block 0x157, offset 0x55c0 0x55c0: 0x0100, 0x55c1: 0x0100, 0x55c2: 0x0100, 0x55c3: 0x0100, 0x55c4: 0x0100, 0x55d0: 0x0008, 0x55d1: 0x0008, 0x55d2: 0x0008, 0x55d3: 0x0008, 0x55d4: 0x0008, 0x55d5: 0x0008, 0x55d6: 0x0008, // Block 0x158, offset 0x5600 0x5600: 0x2000, 0x5601: 0x2000, 0x5602: 0x2000, 0x5603: 0x2000, 0x5604: 0x2000, 0x5605: 0x2000, 0x5606: 0x2000, 0x5607: 0x2000, 0x5608: 0x2000, 0x5609: 0x2000, 0x560a: 0x2000, 0x560b: 0x2000, 0x560c: 0x2000, 0x560d: 0x2000, 0x560e: 0x2000, 0x560f: 0x2000, 0x5610: 0x2000, 0x5611: 0x2000, 0x5612: 0x2000, 0x5613: 0x2000, 0x5614: 0x2000, 0x5615: 0x2000, 0x5616: 0x2000, 0x5617: 0x2000, 0x5618: 0x2000, 0x5619: 0x2000, 0x561a: 0x2000, 0x561b: 0x2000, 0x561c: 0x2000, 0x561d: 0x2000, 0x561e: 0x2000, 0x561f: 0x2000, 0x5620: 0x2000, 0x5621: 0x2000, 0x5622: 0x0040, 0x5623: 0x0040, 0x5624: 0x0040, 0x5625: 0x0040, 0x5626: 0x0040, 0x5627: 0x0040, 0x5628: 0x0040, 0x5629: 0x0040, 0x562a: 0x0040, 0x562b: 0x0040, 0x562c: 0x0040, 0x562d: 0x0040, 0x562e: 0x0040, 0x562f: 0x0040, 0x5630: 0x0040, 0x5631: 0x0040, 0x5632: 0x0040, 0x5633: 0x0040, 0x5634: 0x0040, 0x5635: 0x0040, 0x5636: 0x0040, 0x5637: 0x0040, 0x5638: 0x0040, 0x5639: 0x0040, 0x563a: 0x0040, 0x563b: 0x0040, 0x563c: 0x0040, 0x563d: 0x0040, 0x563e: 0x0040, 0x563f: 0x0040, // Block 0x159, offset 0x5640 0x5640: 0x0040, 0x5641: 0x0040, 0x5642: 0x0040, 0x5643: 0x0040, 0x5644: 0x0008, 0x5645: 0x0008, 0x5646: 0x0008, 0x5647: 0x0008, 0x5648: 0x0008, 0x5649: 0x0008, 0x564a: 0x0008, 0x564b: 0x0100, 0x5650: 0x0080, 0x5651: 0x0080, 0x5652: 0x0080, 0x5653: 0x0080, 0x5654: 0x0080, 0x5655: 0x0080, 0x5656: 0x0080, 0x5657: 0x0080, 0x5658: 0x0080, 0x5659: 0x0080, // Block 0x15a, offset 0x5680 0x5680: 0x0100, 0x5681: 0x0100, 0x5682: 0x0100, 0x5683: 0x0100, 0x5685: 0x0100, 0x5686: 0x0100, 0x5687: 0x0100, 0x5688: 0x0100, 0x5689: 0x0100, 0x568a: 0x0100, 0x568b: 0x0100, 0x568c: 0x0100, 0x568d: 0x0100, 0x568e: 0x0100, 0x568f: 0x0100, 0x5690: 0x0100, 0x5691: 0x0100, 0x5692: 0x0100, 0x5693: 0x0100, 0x5694: 0x0100, 0x5695: 0x0100, 0x5696: 0x0100, 0x5697: 0x0100, 0x5698: 0x0100, 0x5699: 0x0100, 0x569a: 0x0100, 0x569b: 0x0100, 0x569c: 0x0100, 0x569d: 0x0100, 0x569e: 0x0100, 0x569f: 0x0100, 0x56a1: 0x0100, 0x56a2: 0x0100, 0x56a4: 0x0100, 0x56a7: 0x0100, 0x56a9: 0x0100, 0x56aa: 0x0100, 0x56ab: 0x0100, 0x56ac: 0x0100, 0x56ad: 0x0100, 0x56ae: 0x0100, 0x56af: 0x0100, 0x56b0: 0x0100, 0x56b1: 0x0100, 0x56b2: 0x0100, 0x56b4: 0x0100, 0x56b5: 0x0100, 0x56b6: 0x0100, 0x56b7: 0x0100, 0x56b9: 0x0100, 0x56bb: 0x0100, // Block 0x15b, offset 0x56c0 0x56c2: 0x0100, 0x56c7: 0x0100, 0x56c9: 0x0100, 0x56cb: 0x0100, 0x56cd: 0x0100, 0x56ce: 0x0100, 0x56cf: 0x0100, 0x56d1: 0x0100, 0x56d2: 0x0100, 0x56d4: 0x0100, 0x56d7: 0x0100, 0x56d9: 0x0100, 0x56db: 0x0100, 0x56dd: 0x0100, 0x56df: 0x0100, 0x56e1: 0x0100, 0x56e2: 0x0100, 0x56e4: 0x0100, 0x56e7: 0x0100, 0x56e8: 0x0100, 0x56e9: 0x0100, 0x56ea: 0x0100, 0x56ec: 0x0100, 0x56ed: 0x0100, 0x56ee: 0x0100, 0x56ef: 0x0100, 0x56f0: 0x0100, 0x56f1: 0x0100, 0x56f2: 0x0100, 0x56f4: 0x0100, 0x56f5: 0x0100, 0x56f6: 0x0100, 0x56f7: 0x0100, 0x56f9: 0x0100, 0x56fa: 0x0100, 0x56fb: 0x0100, 0x56fc: 0x0100, 0x56fe: 0x0100, // Block 0x15c, offset 0x5700 0x5700: 0x0100, 0x5701: 0x0100, 0x5702: 0x0100, 0x5703: 0x0100, 0x5704: 0x0100, 0x5705: 0x0100, 0x5706: 0x0100, 0x5707: 0x0100, 0x5708: 0x0100, 0x5709: 0x0100, 0x570b: 0x0100, 0x570c: 0x0100, 0x570d: 0x0100, 0x570e: 0x0100, 0x570f: 0x0100, 0x5710: 0x0100, 0x5711: 0x0100, 0x5712: 0x0100, 0x5713: 0x0100, 0x5714: 0x0100, 0x5715: 0x0100, 0x5716: 0x0100, 0x5717: 0x0100, 0x5718: 0x0100, 0x5719: 0x0100, 0x571a: 0x0100, 0x571b: 0x0100, 0x5721: 0x0100, 0x5722: 0x0100, 0x5723: 0x0100, 0x5725: 0x0100, 0x5726: 0x0100, 0x5727: 0x0100, 0x5728: 0x0100, 0x5729: 0x0100, 0x572b: 0x0100, 0x572c: 0x0100, 0x572d: 0x0100, 0x572e: 0x0100, 0x572f: 0x0100, 0x5730: 0x0100, 0x5731: 0x0100, 0x5732: 0x0100, 0x5733: 0x0100, 0x5734: 0x0100, 0x5735: 0x0100, 0x5736: 0x0100, 0x5737: 0x0100, 0x5738: 0x0100, 0x5739: 0x0100, 0x573a: 0x0100, 0x573b: 0x0100, // Block 0x15d, offset 0x5740 0x5770: 0x2000, 0x5771: 0x2000, 0x5772: 0x2000, 0x5773: 0x2000, 0x5774: 0x2000, 0x5775: 0x2000, 0x5776: 0x2000, 0x5777: 0x2000, 0x5778: 0x2000, 0x5779: 0x2000, 0x577a: 0x2000, 0x577b: 0x2000, 0x577c: 0x2000, 0x577d: 0x2000, 0x577e: 0x2000, 0x577f: 0x2000, // Block 0x15e, offset 0x5780 0x5780: 0x2000, 0x5781: 0x2000, 0x5782: 0x2000, 0x5783: 0x2000, 0x5784: 0x2000, 0x5785: 0x2000, 0x5786: 0x2000, 0x5787: 0x2000, 0x5788: 0x2000, 0x5789: 0x2000, 0x5790: 0x2000, 0x5791: 0x2000, 0x5792: 0x2000, 0x5793: 0x2000, 0x5794: 0x2000, 0x5795: 0x2000, 0x5796: 0x2000, 0x5797: 0x2000, 0x5798: 0x2000, 0x5799: 0x2000, 0x579a: 0x2000, 0x579b: 0x2000, 0x579c: 0x2000, 0x579d: 0x2000, 0x579e: 0x2000, 0x579f: 0x2000, 0x57a0: 0x2000, 0x57a1: 0x2000, 0x57a2: 0x2000, 0x57a3: 0x2000, 0x57a4: 0x2000, 0x57a5: 0x2000, 0x57a6: 0x2000, 0x57a7: 0x2000, 0x57a8: 0x2000, 0x57a9: 0x2000, 0x57b0: 0x2000, 0x57b1: 0x2000, 0x57b2: 0x2000, 0x57b3: 0x2000, 0x57b4: 0x2000, 0x57b5: 0x2000, 0x57b6: 0x2000, 0x57b7: 0x2000, 0x57b8: 0x2000, 0x57b9: 0x2000, 0x57ba: 0x2000, 0x57bb: 0x2000, 0x57bc: 0x2000, 0x57bd: 0x2000, 0x57be: 0x2000, 0x57bf: 0x2000, // Block 0x15f, offset 0x57c0 0x57c0: 0x2000, 0x57c1: 0x2000, 0x57c2: 0x2000, 0x57c3: 0x2000, 0x57c4: 0x2000, 0x57c5: 0x2000, 0x57c6: 0x2000, 0x57c7: 0x2000, 0x57c8: 0x2000, 0x57c9: 0x2000, // Block 0x160, offset 0x5800 0x5836: 0x0004, 0x5837: 0x0004, 0x5838: 0x0004, // Block 0x161, offset 0x5840 0x5840: 0x0100, 0x5841: 0x0100, 0x5842: 0x0100, 0x5843: 0x0100, 0x5844: 0x0100, 0x5845: 0x0100, 0x5846: 0x0100, 0x5847: 0x0100, 0x5848: 0x0100, 0x5849: 0x0100, 0x584a: 0x0100, 0x584b: 0x0100, 0x584c: 0x0100, 0x584d: 0x0100, 0x584e: 0x0100, 0x584f: 0x0100, 0x5850: 0x0100, 0x5851: 0x0100, 0x5852: 0x0100, 0x5853: 0x0100, 0x5854: 0x0100, 0x5855: 0x0100, 0x5856: 0x0100, 0x5857: 0x0100, 0x5858: 0x0100, 0x5859: 0x0100, 0x585a: 0x0100, 0x585b: 0x0100, 0x585c: 0x0100, 0x585d: 0x0100, 0x585e: 0x0100, 0x585f: 0x0100, // Block 0x162, offset 0x5880 0x5880: 0x0100, 0x5881: 0x0100, 0x5882: 0x0100, 0x5883: 0x0100, 0x5884: 0x0100, 0x5885: 0x0100, 0x5886: 0x0100, 0x5887: 0x0100, 0x5888: 0x0100, 0x5889: 0x0100, 0x588a: 0x0100, 0x588b: 0x0100, 0x588c: 0x0100, 0x588d: 0x0100, 0x588e: 0x0100, 0x588f: 0x0100, 0x5890: 0x0100, 0x5891: 0x0100, 0x5892: 0x0100, 0x5893: 0x0100, 0x5894: 0x0100, 0x5895: 0x0100, 0x5896: 0x0100, 0x5897: 0x0100, 0x5898: 0x0100, 0x5899: 0x0100, 0x589a: 0x0100, 0x589b: 0x0100, 0x589c: 0x0100, 0x589d: 0x0100, 0x589e: 0x0100, 0x589f: 0x0100, 0x58a0: 0x0100, 0x58b0: 0x0100, 0x58b1: 0x0100, 0x58b2: 0x0100, 0x58b3: 0x0100, 0x58b4: 0x0100, 0x58b5: 0x0100, 0x58b6: 0x0100, 0x58b7: 0x0100, 0x58b8: 0x0100, 0x58b9: 0x0100, 0x58ba: 0x0100, 0x58bb: 0x0100, 0x58bc: 0x0100, 0x58bd: 0x0100, 0x58be: 0x0100, 0x58bf: 0x0100, // Block 0x163, offset 0x58c0 0x58c0: 0x0100, 0x58c1: 0x0100, 0x58c2: 0x0100, 0x58c3: 0x0100, 0x58c4: 0x0100, 0x58c5: 0x0100, 0x58c6: 0x0100, 0x58c7: 0x0100, 0x58c8: 0x0100, 0x58c9: 0x0100, 0x58ca: 0x0100, 0x58cb: 0x0100, 0x58cc: 0x0100, 0x58cd: 0x0100, 0x58ce: 0x0100, 0x58cf: 0x0100, 0x58d0: 0x0100, 0x58d1: 0x0100, 0x58d2: 0x0100, 0x58d3: 0x0100, 0x58d4: 0x0100, 0x58d5: 0x0100, 0x58d6: 0x0100, 0x58d7: 0x0100, 0x58d8: 0x0100, 0x58d9: 0x0100, 0x58da: 0x0100, 0x58db: 0x0100, 0x58dc: 0x0100, 0x58dd: 0x0100, // Block 0x164, offset 0x5900 0x5900: 0x0100, 0x5901: 0x0100, 0x5902: 0x0100, 0x5903: 0x0100, 0x5904: 0x0100, 0x5905: 0x0100, 0x5906: 0x0100, 0x5907: 0x0100, 0x5908: 0x0100, 0x5909: 0x0100, 0x590a: 0x0100, 0x5910: 0x0100, 0x5911: 0x0100, 0x5912: 0x0100, 0x5913: 0x0100, 0x5914: 0x0100, 0x5915: 0x0100, 0x5916: 0x0100, 0x5917: 0x0100, 0x5918: 0x0100, 0x5919: 0x0100, 0x591a: 0x0100, 0x591b: 0x0100, 0x591c: 0x0100, 0x591d: 0x0100, 0x591e: 0x0100, 0x591f: 0x0100, 0x5920: 0x0100, 0x5921: 0x0100, 0x5922: 0x0100, 0x5923: 0x0100, 0x5924: 0x0100, 0x5925: 0x0100, 0x5926: 0x0100, 0x5927: 0x0100, 0x5928: 0x0100, 0x5929: 0x0100, 0x592a: 0x0100, 0x592b: 0x0100, 0x592c: 0x0100, 0x592d: 0x0100, 0x592e: 0x0100, 0x592f: 0x0100, 0x5930: 0x0100, 0x5931: 0x0100, 0x5932: 0x0100, 0x5933: 0x0100, 0x5934: 0x0100, 0x5935: 0x0100, 0x5936: 0x0100, 0x5937: 0x0100, 0x5938: 0x0100, 0x5939: 0x0100, 0x593a: 0x0100, 0x593b: 0x0100, 0x593c: 0x0100, 0x593d: 0x0100, 0x593e: 0x0100, 0x593f: 0x0100, // Block 0x165, offset 0x5940 0x5940: 0x0100, 0x5941: 0x0100, 0x5942: 0x0100, 0x5943: 0x0100, 0x5944: 0x0100, 0x5945: 0x0100, 0x5946: 0x0100, 0x5947: 0x0100, 0x5948: 0x0100, 0x5949: 0x0100, 0x594a: 0x0100, 0x594b: 0x0100, 0x594c: 0x0100, 0x594d: 0x0100, 0x594e: 0x0100, 0x594f: 0x0100, 0x5950: 0x0100, 0x5951: 0x0100, 0x5952: 0x0100, 0x5953: 0x0100, 0x5954: 0x0100, 0x5955: 0x0100, 0x5956: 0x0100, 0x5957: 0x0100, 0x5958: 0x0100, 0x5959: 0x0100, 0x595a: 0x0100, 0x595b: 0x0100, 0x595c: 0x0100, 0x595d: 0x0100, 0x595e: 0x0100, 0x595f: 0x0100, 0x5960: 0x0100, 0x5961: 0x0100, 0x5962: 0x0100, 0x5963: 0x0100, 0x5964: 0x0100, 0x5965: 0x0100, 0x5966: 0x0100, 0x5967: 0x0100, 0x5968: 0x0100, 0x5969: 0x0100, 0x596a: 0x0100, 0x596b: 0x0100, 0x596c: 0x0100, 0x596d: 0x0100, 0x596e: 0x0100, 0x596f: 0x0100, 0x5970: 0x0100, 0x5971: 0x0100, 0x5972: 0x0100, 0x5973: 0x0100, 0x5974: 0x0100, 0x5975: 0x0100, 0x5976: 0x0100, 0x5977: 0x0100, 0x5978: 0x0100, 0x5979: 0x0100, // Block 0x166, offset 0x5980 0x5981: 0x0010, 0x59a0: 0x0008, 0x59a1: 0x0008, 0x59a2: 0x0008, 0x59a3: 0x0008, 0x59a4: 0x0008, 0x59a5: 0x0008, 0x59a6: 0x0008, 0x59a7: 0x0008, 0x59a8: 0x0008, 0x59a9: 0x0008, 0x59aa: 0x0008, 0x59ab: 0x0008, 0x59ac: 0x0008, 0x59ad: 0x0008, 0x59ae: 0x0008, 0x59af: 0x0008, 0x59b0: 0x0008, 0x59b1: 0x0008, 0x59b2: 0x0008, 0x59b3: 0x0008, 0x59b4: 0x0008, 0x59b5: 0x0008, 0x59b6: 0x0008, 0x59b7: 0x0008, 0x59b8: 0x0008, 0x59b9: 0x0008, 0x59ba: 0x0008, 0x59bb: 0x0008, 0x59bc: 0x0008, 0x59bd: 0x0008, 0x59be: 0x0008, 0x59bf: 0x0008, // Block 0x167, offset 0x59c0 0x59c0: 0x0008, 0x59c1: 0x0008, 0x59c2: 0x0008, 0x59c3: 0x0008, 0x59c4: 0x0008, 0x59c5: 0x0008, 0x59c6: 0x0008, 0x59c7: 0x0008, 0x59c8: 0x0008, 0x59c9: 0x0008, 0x59ca: 0x0008, 0x59cb: 0x0008, 0x59cc: 0x0008, 0x59cd: 0x0008, 0x59ce: 0x0008, 0x59cf: 0x0008, 0x59d0: 0x0008, 0x59d1: 0x0008, 0x59d2: 0x0008, 0x59d3: 0x0008, 0x59d4: 0x0008, 0x59d5: 0x0008, 0x59d6: 0x0008, 0x59d7: 0x0008, 0x59d8: 0x0008, 0x59d9: 0x0008, 0x59da: 0x0008, 0x59db: 0x0008, 0x59dc: 0x0008, 0x59dd: 0x0008, 0x59de: 0x0008, 0x59df: 0x0008, 0x59e0: 0x0008, 0x59e1: 0x0008, 0x59e2: 0x0008, 0x59e3: 0x0008, 0x59e4: 0x0008, 0x59e5: 0x0008, 0x59e6: 0x0008, 0x59e7: 0x0008, 0x59e8: 0x0008, 0x59e9: 0x0008, 0x59ea: 0x0008, 0x59eb: 0x0008, 0x59ec: 0x0008, 0x59ed: 0x0008, 0x59ee: 0x0008, 0x59ef: 0x0008, } // sentencesIndex: 36 blocks, 2304 entries, 4608 bytes // Block 0 is the zero block. var sentencesIndex = [2304]property{ // Block 0x0, offset 0x0 // Block 0x1, offset 0x40 // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc2: 0x01, 0xc3: 0x02, 0xc4: 0x03, 0xc5: 0x04, 0xc6: 0x05, 0xc7: 0x06, 0xc8: 0x07, 0xc9: 0x08, 0xca: 0x09, 0xcb: 0x0a, 0xcc: 0x0b, 0xcd: 0x0c, 0xce: 0x0d, 0xcf: 0x0e, 0xd0: 0x0f, 0xd1: 0x10, 0xd2: 0x11, 0xd3: 0x12, 0xd4: 0x13, 0xd5: 0x14, 0xd6: 0x15, 0xd7: 0x16, 0xd8: 0x17, 0xd9: 0x18, 0xda: 0x19, 0xdb: 0x1a, 0xdc: 0x1b, 0xdd: 0x1c, 0xde: 0x1d, 0xdf: 0x1e, 0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xe4: 0x06, 0xe5: 0x07, 0xe6: 0x07, 0xe7: 0x07, 0xe8: 0x07, 0xe9: 0x07, 0xea: 0x08, 0xeb: 0x07, 0xec: 0x07, 0xed: 0x09, 0xef: 0x0a, 0xf0: 0x1f, 0xf3: 0x21, // Block 0x4, offset 0x100 0x120: 0x1f, 0x121: 0x20, 0x122: 0x21, 0x123: 0x22, 0x124: 0x23, 0x125: 0x24, 0x126: 0x25, 0x127: 0x26, 0x128: 0x27, 0x129: 0x28, 0x12a: 0x29, 0x12b: 0x2a, 0x12c: 0x2b, 0x12d: 0x2c, 0x12e: 0x2d, 0x12f: 0x2e, 0x130: 0x2f, 0x131: 0x30, 0x132: 0x31, 0x133: 0x32, 0x134: 0x33, 0x135: 0x34, 0x136: 0x35, 0x137: 0x36, 0x138: 0x37, 0x139: 0x38, 0x13a: 0x39, 0x13b: 0x3a, 0x13c: 0x3b, 0x13d: 0x3c, 0x13e: 0x3d, 0x13f: 0x3e, // Block 0x5, offset 0x140 0x140: 0x3f, 0x141: 0x40, 0x142: 0x41, 0x143: 0x42, 0x144: 0x19, 0x145: 0x19, 0x146: 0x19, 0x147: 0x19, 0x148: 0x19, 0x149: 0x43, 0x14a: 0x44, 0x14b: 0x45, 0x14c: 0x46, 0x14d: 0x47, 0x14e: 0x48, 0x14f: 0x49, 0x150: 0x4a, 0x151: 0x19, 0x152: 0x19, 0x153: 0x19, 0x154: 0x19, 0x155: 0x19, 0x156: 0x19, 0x157: 0x19, 0x158: 0x19, 0x159: 0x4b, 0x15a: 0x4c, 0x15b: 0x4d, 0x15c: 0x4e, 0x15d: 0x4f, 0x15e: 0x50, 0x15f: 0x51, 0x160: 0x52, 0x161: 0x53, 0x162: 0x54, 0x163: 0x55, 0x164: 0x56, 0x165: 0x57, 0x166: 0x58, 0x167: 0x59, 0x168: 0x5a, 0x169: 0x5b, 0x16a: 0x5c, 0x16b: 0x5d, 0x16c: 0x5e, 0x16d: 0x5f, 0x16e: 0x60, 0x16f: 0x61, 0x170: 0x62, 0x171: 0x63, 0x172: 0x64, 0x173: 0x65, 0x174: 0x66, 0x175: 0x66, 0x176: 0x66, 0x177: 0x0b, 0x178: 0x67, 0x179: 0x67, 0x17a: 0x68, 0x17b: 0x67, 0x17c: 0x69, 0x17d: 0x6a, 0x17e: 0x6b, 0x17f: 0x6c, // Block 0x6, offset 0x180 0x180: 0x6d, 0x181: 0x6e, 0x182: 0x6f, 0x183: 0x70, 0x184: 0x71, 0x185: 0x72, 0x186: 0x73, 0x18c: 0x74, 0x192: 0x75, 0x193: 0x76, 0x19d: 0x77, 0x19f: 0x78, 0x1a6: 0x79, 0x1a7: 0x7a, 0x1b0: 0x0f, 0x1b1: 0x7b, 0x1b2: 0x67, 0x1b3: 0x7c, 0x1b4: 0x7d, 0x1b5: 0x7e, 0x1b6: 0x7f, 0x1b7: 0x80, 0x1b8: 0x81, 0x1b9: 0x82, // Block 0x7, offset 0x1c0 0x1c0: 0x83, 0x1c1: 0x4a, 0x1c2: 0x84, 0x1c3: 0x85, 0x1c4: 0x86, 0x1c5: 0x19, 0x1c6: 0x87, 0x1c7: 0x88, 0x1d0: 0x19, 0x1d1: 0x19, 0x1d2: 0x19, 0x1d3: 0x19, 0x1d4: 0x19, 0x1d5: 0x19, 0x1d6: 0x19, 0x1d7: 0x19, 0x1d8: 0x19, 0x1d9: 0x19, 0x1da: 0x19, 0x1db: 0x19, 0x1dc: 0x19, 0x1dd: 0x19, 0x1de: 0x19, 0x1df: 0x19, 0x1e0: 0x19, 0x1e1: 0x19, 0x1e2: 0x19, 0x1e3: 0x19, 0x1e4: 0x19, 0x1e5: 0x19, 0x1e6: 0x19, 0x1e7: 0x19, 0x1e8: 0x19, 0x1e9: 0x19, 0x1ea: 0x19, 0x1eb: 0x19, 0x1ec: 0x19, 0x1ed: 0x19, 0x1ee: 0x19, 0x1ef: 0x19, 0x1f0: 0x19, 0x1f1: 0x19, 0x1f2: 0x19, 0x1f3: 0x19, 0x1f4: 0x19, 0x1f5: 0x19, 0x1f6: 0x19, 0x1f7: 0x19, 0x1f8: 0x19, 0x1f9: 0x19, 0x1fa: 0x19, 0x1fb: 0x19, 0x1fc: 0x19, 0x1fd: 0x19, 0x1fe: 0x19, 0x1ff: 0x19, // Block 0x8, offset 0x200 0x200: 0x19, 0x201: 0x19, 0x202: 0x19, 0x203: 0x19, 0x204: 0x19, 0x205: 0x19, 0x206: 0x19, 0x207: 0x19, 0x208: 0x19, 0x209: 0x19, 0x20a: 0x19, 0x20b: 0x19, 0x20c: 0x19, 0x20d: 0x19, 0x20e: 0x19, 0x20f: 0x19, 0x210: 0x19, 0x211: 0x19, 0x212: 0x19, 0x213: 0x19, 0x214: 0x19, 0x215: 0x19, 0x216: 0x19, 0x217: 0x19, 0x218: 0x19, 0x219: 0x19, 0x21a: 0x19, 0x21b: 0x19, 0x21c: 0x19, 0x21d: 0x19, 0x21e: 0x19, 0x21f: 0x19, 0x220: 0x19, 0x221: 0x19, 0x222: 0x19, 0x223: 0x19, 0x224: 0x19, 0x225: 0x19, 0x226: 0x19, 0x227: 0x19, 0x228: 0x19, 0x229: 0x19, 0x22a: 0x19, 0x22b: 0x19, 0x22c: 0x19, 0x22d: 0x19, 0x22e: 0x19, 0x22f: 0x19, 0x230: 0x19, 0x231: 0x19, 0x232: 0x19, 0x233: 0x19, 0x234: 0x19, 0x235: 0x19, 0x236: 0x19, 0x238: 0x19, 0x239: 0x19, 0x23a: 0x19, 0x23b: 0x19, 0x23c: 0x19, 0x23d: 0x19, 0x23e: 0x19, 0x23f: 0x19, // Block 0x9, offset 0x240 0x240: 0x19, 0x241: 0x19, 0x242: 0x19, 0x243: 0x19, 0x244: 0x19, 0x245: 0x19, 0x246: 0x19, 0x247: 0x19, 0x248: 0x19, 0x249: 0x19, 0x24a: 0x19, 0x24b: 0x19, 0x24c: 0x19, 0x24d: 0x19, 0x24e: 0x19, 0x24f: 0x19, 0x250: 0x19, 0x251: 0x19, 0x252: 0x19, 0x253: 0x19, 0x254: 0x19, 0x255: 0x19, 0x256: 0x19, 0x257: 0x19, 0x258: 0x19, 0x259: 0x19, 0x25a: 0x19, 0x25b: 0x19, 0x25c: 0x19, 0x25d: 0x19, 0x25e: 0x19, 0x25f: 0x19, 0x260: 0x19, 0x261: 0x19, 0x262: 0x19, 0x263: 0x19, 0x264: 0x19, 0x265: 0x19, 0x266: 0x19, 0x267: 0x19, 0x268: 0x19, 0x269: 0x19, 0x26a: 0x19, 0x26b: 0x19, 0x26c: 0x19, 0x26d: 0x19, 0x26e: 0x19, 0x26f: 0x19, 0x270: 0x19, 0x271: 0x19, 0x272: 0x19, 0x273: 0x19, 0x274: 0x19, 0x275: 0x19, 0x276: 0x19, 0x277: 0x19, 0x278: 0x19, 0x279: 0x19, 0x27a: 0x19, 0x27b: 0x19, 0x27c: 0x19, 0x27d: 0x19, 0x27e: 0x19, 0x27f: 0x19, // Block 0xa, offset 0x280 0x280: 0x19, 0x281: 0x19, 0x282: 0x19, 0x283: 0x19, 0x284: 0x19, 0x285: 0x19, 0x286: 0x19, 0x287: 0x19, 0x288: 0x19, 0x289: 0x19, 0x28a: 0x19, 0x28b: 0x19, 0x28c: 0x19, 0x28d: 0x19, 0x28e: 0x19, 0x28f: 0x19, 0x290: 0x19, 0x291: 0x19, 0x292: 0x89, 0x293: 0x8a, 0x294: 0x19, 0x295: 0x19, 0x296: 0x19, 0x297: 0x19, 0x298: 0x8b, 0x299: 0x8c, 0x29a: 0x8d, 0x29b: 0x8e, 0x29c: 0x8f, 0x29d: 0x90, 0x29e: 0x91, 0x29f: 0x92, 0x2a0: 0x93, 0x2a1: 0x94, 0x2a2: 0x95, 0x2a3: 0x96, 0x2a4: 0x97, 0x2a5: 0x98, 0x2a6: 0x99, 0x2a7: 0x9a, 0x2a8: 0x9b, 0x2a9: 0x9c, 0x2aa: 0x9d, 0x2ab: 0x9e, 0x2ac: 0x9f, 0x2ad: 0xa0, 0x2ae: 0x66, 0x2af: 0xa1, 0x2b0: 0x19, 0x2b1: 0x19, 0x2b2: 0x19, 0x2b3: 0x19, 0x2b4: 0x19, 0x2b5: 0x19, 0x2b6: 0x19, 0x2b7: 0x19, 0x2b8: 0x19, 0x2b9: 0x19, 0x2ba: 0x19, 0x2bb: 0x19, 0x2bc: 0x19, 0x2bd: 0x19, 0x2be: 0x19, 0x2bf: 0x19, // Block 0xb, offset 0x2c0 0x2c0: 0x19, 0x2c1: 0x19, 0x2c2: 0x19, 0x2c3: 0x19, 0x2c4: 0x19, 0x2c5: 0x19, 0x2c6: 0x19, 0x2c7: 0x19, 0x2c8: 0x19, 0x2c9: 0x19, 0x2ca: 0x19, 0x2cb: 0x19, 0x2cc: 0x19, 0x2cd: 0x19, 0x2ce: 0x19, 0x2cf: 0x19, 0x2d0: 0x19, 0x2d1: 0x19, 0x2d2: 0x19, 0x2d3: 0x19, 0x2d4: 0x19, 0x2d5: 0x19, 0x2d6: 0x19, 0x2d7: 0x19, 0x2d8: 0x19, 0x2d9: 0x19, 0x2da: 0x19, 0x2db: 0x19, 0x2dc: 0x19, 0x2dd: 0x19, 0x2de: 0xa2, 0x2df: 0xa3, // Block 0xc, offset 0x300 0x324: 0x19, 0x325: 0x19, 0x326: 0x19, 0x327: 0x19, 0x328: 0x19, 0x329: 0xa4, 0x32a: 0x19, 0x32b: 0xa5, 0x32c: 0xa6, 0x32d: 0xa7, 0x32e: 0xa8, 0x32f: 0xa9, 0x330: 0x19, 0x331: 0x19, 0x332: 0x19, 0x333: 0x19, 0x334: 0xaa, 0x335: 0xab, 0x336: 0xac, 0x337: 0xad, 0x338: 0xae, 0x339: 0xaf, 0x33a: 0x19, 0x33b: 0xb0, 0x33c: 0xb1, 0x33d: 0xb2, 0x33e: 0xb3, 0x33f: 0xb4, // Block 0xd, offset 0x340 0x340: 0xb5, 0x341: 0xb6, 0x342: 0x19, 0x343: 0xb7, 0x345: 0xb8, 0x347: 0xb9, 0x34a: 0xba, 0x34b: 0xbb, 0x34c: 0xbc, 0x34d: 0xbd, 0x34e: 0xbe, 0x34f: 0xbf, 0x350: 0xc0, 0x351: 0xc1, 0x352: 0xc2, 0x353: 0xc3, 0x354: 0xc4, 0x355: 0xc5, 0x356: 0xc6, 0x357: 0xc7, 0x358: 0x19, 0x359: 0x19, 0x35a: 0x19, 0x35b: 0x19, 0x35c: 0xc8, 0x35d: 0xc9, 0x35e: 0xca, 0x360: 0xcb, 0x361: 0xcc, 0x362: 0xcd, 0x363: 0xce, 0x364: 0xcf, 0x365: 0xa5, 0x366: 0xd0, 0x368: 0xd1, 0x369: 0xd2, 0x36a: 0xd3, 0x36b: 0xd4, 0x36c: 0x55, 0x36d: 0xd5, 0x36e: 0xd6, 0x370: 0x19, 0x371: 0xd7, 0x372: 0xd8, 0x373: 0xd9, 0x374: 0xda, 0x375: 0xdb, 0x376: 0xdc, 0x37a: 0xdd, 0x37b: 0xde, 0x37c: 0xdf, 0x37d: 0xe0, 0x37e: 0xe1, 0x37f: 0xe2, // Block 0xe, offset 0x380 0x380: 0xe3, 0x381: 0xe4, 0x382: 0xe5, 0x383: 0xe6, 0x384: 0xe7, 0x385: 0xe8, 0x386: 0xe9, 0x387: 0xea, 0x388: 0xeb, 0x389: 0xec, 0x38a: 0xed, 0x38b: 0xee, 0x38c: 0xef, 0x38d: 0xf0, 0x38e: 0xf1, 0x38f: 0xf2, 0x390: 0xf3, 0x391: 0xf4, 0x392: 0xf5, 0x393: 0xf6, 0x396: 0xf7, 0x397: 0xf8, 0x398: 0xf5, 0x399: 0xf9, 0x39a: 0xfa, 0x39b: 0xfb, 0x39c: 0xfc, 0x39d: 0xfd, 0x3a0: 0xfe, 0x3a2: 0xff, 0x3a3: 0x100, 0x3a4: 0x101, 0x3a5: 0x102, 0x3a6: 0x103, 0x3a7: 0x104, 0x3a8: 0x105, 0x3a9: 0x106, 0x3aa: 0x107, 0x3ab: 0x53, 0x3ad: 0x108, 0x3af: 0x109, 0x3b0: 0x10a, 0x3b1: 0x10b, 0x3b2: 0x10c, 0x3b4: 0x10d, 0x3b5: 0x10e, 0x3b6: 0x10f, 0x3b7: 0x110, 0x3bb: 0x111, 0x3bc: 0x112, 0x3bd: 0x113, 0x3be: 0x114, // Block 0xf, offset 0x3c0 0x3c0: 0x19, 0x3c1: 0x19, 0x3c2: 0x19, 0x3c3: 0x19, 0x3c4: 0x19, 0x3c5: 0x19, 0x3c6: 0x19, 0x3c7: 0x19, 0x3c8: 0x19, 0x3c9: 0x19, 0x3ca: 0x19, 0x3cb: 0x19, 0x3cc: 0x19, 0x3cd: 0x19, 0x3ce: 0xa5, 0x3d0: 0x19, 0x3d1: 0x115, 0x3d2: 0x19, 0x3d3: 0x19, 0x3d4: 0x19, 0x3d5: 0x116, 0x3fe: 0xab, 0x3ff: 0x117, // Block 0x10, offset 0x400 0x400: 0x19, 0x401: 0x19, 0x402: 0x19, 0x403: 0x19, 0x404: 0x19, 0x405: 0x19, 0x406: 0x19, 0x407: 0x19, 0x408: 0x19, 0x409: 0x19, 0x40a: 0x19, 0x40b: 0x19, 0x40c: 0x19, 0x40d: 0x19, 0x40e: 0x19, 0x40f: 0x19, 0x410: 0x118, 0x411: 0x119, 0x412: 0x19, 0x413: 0x19, 0x414: 0x19, 0x415: 0x19, 0x416: 0x19, 0x417: 0x19, 0x418: 0x19, 0x419: 0x19, 0x41a: 0x19, 0x41b: 0x19, 0x41c: 0x19, 0x41d: 0x19, 0x41e: 0x19, 0x41f: 0x19, 0x420: 0x19, 0x421: 0x19, 0x422: 0x19, 0x423: 0x19, 0x424: 0x19, 0x425: 0x19, 0x426: 0x19, 0x427: 0x19, 0x428: 0x19, 0x429: 0x19, 0x42a: 0x19, 0x42b: 0x19, 0x42c: 0x19, 0x42d: 0x19, 0x42e: 0x19, 0x42f: 0x19, 0x430: 0x19, 0x431: 0x19, 0x432: 0x19, 0x433: 0x19, 0x434: 0x19, 0x435: 0x19, 0x436: 0x19, 0x437: 0x19, 0x438: 0x19, 0x439: 0x19, 0x43a: 0x19, 0x43b: 0x19, 0x43c: 0x19, 0x43d: 0x19, 0x43e: 0x19, 0x43f: 0x19, // Block 0x11, offset 0x440 0x440: 0x19, 0x441: 0x19, 0x442: 0x19, 0x443: 0x19, 0x444: 0x19, 0x445: 0x19, 0x446: 0x19, 0x447: 0x19, 0x448: 0x19, 0x449: 0x19, 0x44a: 0x19, 0x44b: 0x19, 0x44c: 0x19, 0x44d: 0x19, 0x44e: 0x19, 0x44f: 0xb7, 0x450: 0x19, 0x451: 0x19, 0x452: 0x19, 0x453: 0x19, 0x454: 0x19, 0x455: 0x19, 0x456: 0x19, 0x457: 0x19, 0x458: 0x19, 0x459: 0xfd, // Block 0x12, offset 0x480 0x484: 0x11a, 0x4a0: 0x19, 0x4a1: 0x19, 0x4a2: 0x19, 0x4a3: 0x19, 0x4a4: 0x19, 0x4a5: 0x19, 0x4a6: 0x19, 0x4a7: 0x19, 0x4a8: 0x53, 0x4a9: 0x11b, 0x4aa: 0x11c, 0x4ab: 0x11d, 0x4ac: 0x11e, 0x4ad: 0x11f, 0x4ae: 0x120, 0x4b5: 0x121, 0x4b9: 0x122, 0x4ba: 0x123, 0x4bb: 0x124, 0x4bc: 0x19, 0x4bd: 0x125, 0x4be: 0x126, 0x4bf: 0x127, // Block 0x13, offset 0x4c0 0x4c0: 0x19, 0x4c1: 0x19, 0x4c2: 0x19, 0x4c3: 0x19, 0x4c4: 0x19, 0x4c5: 0x19, 0x4c6: 0x19, 0x4c7: 0x19, 0x4c8: 0x19, 0x4c9: 0x19, 0x4ca: 0x19, 0x4cb: 0x19, 0x4cc: 0x19, 0x4cd: 0x19, 0x4ce: 0x19, 0x4cf: 0x19, 0x4d0: 0x19, 0x4d1: 0x19, 0x4d2: 0x19, 0x4d3: 0x19, 0x4d4: 0x19, 0x4d5: 0x19, 0x4d6: 0x19, 0x4d7: 0x19, 0x4d8: 0x19, 0x4d9: 0x19, 0x4da: 0x19, 0x4db: 0x19, 0x4dc: 0x19, 0x4dd: 0x19, 0x4de: 0x19, 0x4df: 0x19, 0x4e0: 0x19, 0x4e1: 0x19, 0x4e2: 0x19, 0x4e3: 0x19, 0x4e4: 0x19, 0x4e5: 0x19, 0x4e6: 0x19, 0x4e7: 0x19, 0x4e8: 0x19, 0x4e9: 0x19, 0x4ea: 0x19, 0x4eb: 0x19, 0x4ec: 0x19, 0x4ed: 0x19, 0x4ee: 0x19, 0x4ef: 0x19, 0x4f0: 0x19, 0x4f1: 0x19, 0x4f2: 0x19, 0x4f3: 0x128, 0x4f4: 0xcd, 0x4f6: 0x19, 0x4f7: 0x129, // Block 0x14, offset 0x500 0x53f: 0x12a, // Block 0x15, offset 0x540 0x540: 0x19, 0x541: 0x19, 0x542: 0x19, 0x543: 0x19, 0x544: 0x12b, 0x545: 0x12c, 0x546: 0x19, 0x547: 0x19, 0x548: 0x19, 0x549: 0x19, 0x54a: 0x19, 0x54b: 0x12d, 0x570: 0x19, 0x571: 0x12e, 0x572: 0x12f, // Block 0x16, offset 0x580 0x5b3: 0x130, 0x5bc: 0x131, 0x5bd: 0x132, // Block 0x17, offset 0x5c0 0x5c5: 0x133, 0x5c6: 0x134, 0x5c9: 0x135, 0x5d0: 0x136, 0x5d1: 0x137, 0x5d2: 0x138, 0x5d3: 0x139, 0x5d4: 0x13a, 0x5d5: 0x13b, 0x5d6: 0x13c, 0x5d7: 0x13d, 0x5d8: 0x13e, 0x5d9: 0x13f, 0x5da: 0x140, 0x5db: 0x141, 0x5dc: 0x142, 0x5dd: 0x143, 0x5de: 0x144, 0x5df: 0x145, 0x5e8: 0x146, 0x5e9: 0x147, 0x5ea: 0x148, 0x5fc: 0x149, // Block 0x18, offset 0x600 0x600: 0x14a, 0x601: 0x14b, 0x602: 0x14c, 0x604: 0x14d, 0x605: 0x14e, 0x60a: 0x14f, 0x60b: 0x150, 0x613: 0x151, 0x617: 0x152, 0x61b: 0x153, 0x61f: 0x154, 0x620: 0x19, 0x621: 0x19, 0x622: 0x19, 0x623: 0x155, 0x624: 0x156, 0x625: 0x157, 0x638: 0x158, 0x639: 0x159, 0x63a: 0x15a, // Block 0x19, offset 0x640 0x644: 0x15b, 0x645: 0x15c, 0x646: 0x15d, 0x659: 0x15e, 0x66f: 0x130, // Block 0x1a, offset 0x680 0x680: 0x19, 0x681: 0x19, 0x682: 0x19, 0x683: 0x19, 0x684: 0x19, 0x685: 0x19, 0x686: 0x19, 0x687: 0x19, 0x688: 0x19, 0x689: 0x19, 0x68a: 0x19, 0x68b: 0x19, 0x68c: 0x19, 0x68d: 0x19, 0x68e: 0x19, 0x68f: 0x19, 0x690: 0x19, 0x691: 0x19, 0x692: 0x19, 0x693: 0x19, 0x694: 0x19, 0x695: 0x19, 0x696: 0x19, 0x697: 0x19, 0x698: 0x19, 0x699: 0x19, 0x69a: 0x19, 0x69b: 0x15f, 0x69c: 0x19, 0x69d: 0x19, 0x69e: 0x19, 0x69f: 0x19, 0x6a0: 0x19, 0x6a1: 0x19, 0x6a2: 0x19, 0x6a3: 0x19, 0x6a4: 0x19, 0x6a5: 0x19, 0x6a6: 0x19, 0x6a7: 0x19, 0x6a8: 0x19, 0x6a9: 0x19, 0x6aa: 0x19, 0x6ab: 0x19, 0x6ac: 0x19, 0x6ad: 0x19, 0x6ae: 0x19, 0x6af: 0x19, 0x6b0: 0x19, 0x6b1: 0x19, 0x6b2: 0x19, 0x6b3: 0x19, 0x6b4: 0x19, 0x6b5: 0x19, 0x6b6: 0x19, 0x6b7: 0x19, 0x6b8: 0x19, 0x6b9: 0x19, 0x6ba: 0x19, 0x6bb: 0x19, 0x6bc: 0x19, 0x6bd: 0x19, 0x6be: 0x19, 0x6bf: 0x19, // Block 0x1b, offset 0x6c0 0x6c0: 0x19, 0x6c1: 0x19, 0x6c2: 0x19, 0x6c3: 0x19, 0x6c4: 0x19, 0x6c5: 0x19, 0x6c6: 0x19, 0x6c7: 0x19, 0x6c8: 0x19, 0x6c9: 0x19, 0x6ca: 0x19, 0x6cb: 0x19, 0x6cc: 0x19, 0x6cd: 0x19, 0x6ce: 0x19, 0x6cf: 0x19, 0x6d0: 0x19, 0x6d1: 0x19, 0x6d2: 0x19, 0x6d3: 0x19, 0x6d4: 0x19, 0x6d5: 0x19, 0x6d6: 0x19, 0x6d7: 0x19, 0x6d8: 0x19, 0x6d9: 0x19, 0x6da: 0x19, 0x6db: 0x19, 0x6dc: 0x19, 0x6dd: 0x19, 0x6de: 0x19, 0x6df: 0x19, 0x6e0: 0xbe, 0x6e1: 0x19, 0x6e2: 0x19, 0x6e3: 0x19, 0x6e4: 0x19, 0x6e5: 0x19, 0x6e6: 0x19, 0x6e7: 0x19, 0x6e8: 0x19, 0x6e9: 0x19, 0x6ea: 0x19, 0x6eb: 0x19, 0x6ec: 0x19, 0x6ed: 0x19, 0x6ee: 0x19, 0x6ef: 0x19, 0x6f0: 0x19, 0x6f1: 0x19, 0x6f2: 0x19, 0x6f3: 0x19, 0x6f4: 0x19, 0x6f5: 0x19, 0x6f6: 0x19, 0x6f7: 0x19, 0x6f8: 0x19, 0x6f9: 0x19, 0x6fa: 0x19, 0x6fb: 0x19, 0x6fc: 0x19, 0x6fd: 0x19, 0x6fe: 0x19, 0x6ff: 0x19, // Block 0x1c, offset 0x700 0x700: 0x19, 0x701: 0x19, 0x702: 0x19, 0x703: 0x19, 0x704: 0x19, 0x705: 0x19, 0x706: 0x19, 0x707: 0x19, 0x708: 0x19, 0x709: 0x19, 0x70a: 0x19, 0x70b: 0x19, 0x70c: 0x19, 0x70d: 0x19, 0x70e: 0x19, 0x70f: 0x19, 0x710: 0x19, 0x711: 0x19, 0x712: 0x19, 0x713: 0x19, 0x714: 0x19, 0x715: 0x19, 0x716: 0x19, 0x717: 0x19, 0x718: 0x19, 0x719: 0x19, 0x71a: 0x19, 0x71b: 0x19, 0x71c: 0x19, 0x71d: 0x19, 0x71e: 0x19, 0x71f: 0x19, 0x720: 0x19, 0x721: 0x19, 0x722: 0x19, 0x723: 0x19, 0x724: 0x19, 0x725: 0x19, 0x726: 0x19, 0x727: 0x19, 0x728: 0x19, 0x729: 0x19, 0x72a: 0x19, 0x72b: 0x19, 0x72c: 0x19, 0x72d: 0x19, 0x72e: 0x19, 0x72f: 0x19, 0x730: 0x19, 0x731: 0x19, 0x732: 0x19, 0x733: 0x19, 0x734: 0x19, 0x735: 0x19, 0x736: 0x19, 0x737: 0x19, 0x738: 0x19, 0x739: 0x19, 0x73a: 0xa4, 0x73b: 0x19, 0x73c: 0x19, 0x73d: 0x19, 0x73e: 0x19, 0x73f: 0x19, // Block 0x1d, offset 0x740 0x740: 0x19, 0x741: 0x19, 0x742: 0x19, 0x743: 0x19, 0x744: 0x19, 0x745: 0x19, 0x746: 0x19, 0x747: 0x19, 0x748: 0x19, 0x749: 0x19, 0x74a: 0x19, 0x74b: 0x19, 0x74c: 0x19, 0x74d: 0x19, 0x74e: 0x19, 0x74f: 0x19, 0x750: 0x19, 0x751: 0x19, 0x752: 0x19, 0x753: 0x19, 0x754: 0x19, 0x755: 0x19, 0x756: 0x19, 0x757: 0x19, 0x758: 0x19, 0x759: 0x19, 0x75a: 0x19, 0x75b: 0x19, 0x75c: 0x19, 0x75d: 0x19, 0x75e: 0x19, 0x75f: 0x19, 0x760: 0x19, 0x761: 0x19, 0x762: 0x19, 0x763: 0x19, 0x764: 0x19, 0x765: 0x19, 0x766: 0x19, 0x767: 0x19, 0x768: 0x19, 0x769: 0x19, 0x76a: 0x19, 0x76b: 0x19, 0x76c: 0x19, 0x76d: 0x19, 0x76e: 0x19, 0x76f: 0x160, 0x770: 0x19, 0x771: 0x19, 0x772: 0x19, 0x773: 0x19, 0x774: 0x19, 0x775: 0x19, 0x776: 0x19, 0x777: 0x19, 0x778: 0x19, 0x779: 0x161, // Block 0x1e, offset 0x780 0x7a0: 0x19, 0x7a1: 0x19, 0x7a2: 0x19, 0x7a3: 0x19, 0x7a4: 0x19, 0x7a5: 0x19, 0x7a6: 0x19, 0x7a7: 0x19, 0x7a8: 0x161, // Block 0x1f, offset 0x7c0 0x7c0: 0x19, 0x7c1: 0x19, 0x7c2: 0x19, 0x7c3: 0x19, 0x7c4: 0x19, 0x7c5: 0x19, 0x7c6: 0x19, 0x7c7: 0x19, 0x7c8: 0x19, 0x7c9: 0x19, 0x7ca: 0x19, 0x7cb: 0x19, 0x7cc: 0x19, 0x7cd: 0x162, 0x7ce: 0x19, 0x7cf: 0x19, 0x7d0: 0x19, 0x7d1: 0x19, 0x7d2: 0x19, 0x7d3: 0x19, 0x7d4: 0x19, 0x7d5: 0x19, 0x7d6: 0x19, 0x7d7: 0x19, 0x7d8: 0x19, 0x7d9: 0x19, 0x7da: 0x19, 0x7db: 0x19, 0x7dc: 0x19, 0x7dd: 0x19, 0x7de: 0x19, 0x7df: 0x19, 0x7e0: 0x19, 0x7e1: 0x19, 0x7e2: 0x19, 0x7e3: 0x19, 0x7e4: 0x19, 0x7e5: 0x19, 0x7e6: 0x19, 0x7e7: 0x19, 0x7e8: 0x19, 0x7e9: 0x19, 0x7ea: 0x19, 0x7eb: 0x19, 0x7ec: 0x19, 0x7ed: 0x19, 0x7ee: 0x19, 0x7ef: 0x19, 0x7f0: 0x19, 0x7f1: 0x19, 0x7f2: 0x19, 0x7f3: 0x19, 0x7f4: 0x19, 0x7f5: 0x19, 0x7f6: 0x19, 0x7f7: 0x19, 0x7f8: 0x19, 0x7f9: 0x19, 0x7fa: 0x19, 0x7fb: 0x19, 0x7fc: 0x19, 0x7fd: 0x19, 0x7fe: 0x19, 0x7ff: 0x19, // Block 0x20, offset 0x800 0x800: 0x19, 0x801: 0x19, 0x802: 0x19, 0x803: 0x19, 0x804: 0x19, 0x805: 0x19, 0x806: 0x19, 0x807: 0x19, 0x808: 0x19, 0x809: 0x19, 0x80a: 0x19, 0x80b: 0x19, 0x80c: 0x19, 0x80d: 0x19, 0x80e: 0x19, 0x80f: 0x19, 0x810: 0x19, 0x811: 0x163, // Block 0x21, offset 0x840 0x850: 0x0b, 0x851: 0x0c, 0x852: 0x0d, 0x853: 0x0e, 0x854: 0x0f, 0x856: 0x10, 0x857: 0x07, 0x858: 0x11, 0x85a: 0x12, 0x85b: 0x13, 0x85c: 0x14, 0x85d: 0x15, 0x85e: 0x16, 0x85f: 0x17, 0x860: 0x07, 0x861: 0x07, 0x862: 0x07, 0x863: 0x07, 0x864: 0x07, 0x865: 0x07, 0x866: 0x07, 0x867: 0x07, 0x868: 0x07, 0x869: 0x07, 0x86a: 0x18, 0x86b: 0x19, 0x86c: 0x1a, 0x86d: 0x07, 0x86e: 0x1b, 0x86f: 0x1c, 0x870: 0x07, 0x871: 0x1d, 0x872: 0x07, 0x873: 0x1e, // Block 0x22, offset 0x880 0x880: 0x164, 0x881: 0x0b, 0x884: 0x0b, 0x885: 0x0b, 0x886: 0x0b, 0x887: 0x165, // Block 0x23, offset 0x8c0 0x8e0: 0x20, } golang-github-clipperhouse-uax29-2.7.0/sentences/unicode_test.go000066400000000000000000004163061515045622700247410ustar00rootroot00000000000000package sentences_test // generated by github.com/clipperhouse/uax29/v2 // from https://www.unicode.org/Public/17.0.0/ucd/auxiliary/SentenceBreakTest.txt type unicodeTest struct { input []byte expected [][]byte comment string } var unicodeTests = [512]unicodeTest{ { input: []byte{0xd, 0xd}, expected: [][]byte{{0xd}, {0xd}}, comment: "÷ [0.2] (CR) ÷ [4.0] (CR) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xd}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xd, 0xa}, expected: [][]byte{{0xd, 0xa}}, comment: "÷ [0.2] (CR) × [3.0] (LF) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xa}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x80}, expected: [][]byte{{0xd}, {0xcc, 0x80}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xd, 0xc2, 0xad}, expected: [][]byte{{0xd}, {0xc2, 0xad}}, comment: "÷ [0.2] (CR) ÷ [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xd, 0xc2, 0x85}, expected: [][]byte{{0xd}, {0xc2, 0x85}}, comment: "÷ [0.2] (CR) ÷ [4.0] (Sep) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xd, 0x9}, expected: [][]byte{{0xd}, {0x9}}, comment: "÷ [0.2] (CR) ÷ [4.0] (Sp) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x9}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x9}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xd, 0x61}, expected: [][]byte{{0xd}, {0x61}}, comment: "÷ [0.2] (CR) ÷ [4.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x61}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x61}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xd, 0x41}, expected: [][]byte{{0xd}, {0x41}}, comment: "÷ [0.2] (CR) ÷ [4.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x41}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xd, 0xc6, 0xbb}, expected: [][]byte{{0xd}, {0xc6, 0xbb}}, comment: "÷ [0.2] (CR) ÷ [4.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xd, 0x30}, expected: [][]byte{{0xd}, {0x30}}, comment: "÷ [0.2] (CR) ÷ [4.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x30}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xd, 0x2e}, expected: [][]byte{{0xd}, {0x2e}}, comment: "÷ [0.2] (CR) ÷ [4.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xd, 0x21}, expected: [][]byte{{0xd}, {0x21}}, comment: "÷ [0.2] (CR) ÷ [4.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x21}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x21}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xd, 0x22}, expected: [][]byte{{0xd}, {0x22}}, comment: "÷ [0.2] (CR) ÷ [4.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x22}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xd, 0x2c}, expected: [][]byte{{0xd}, {0x2c}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xd, 0x0}, expected: [][]byte{{0xd}, {0x0}}, comment: "÷ [0.2] (CR) ÷ [4.0] (XX) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0x0}}, comment: "÷ [0.2] (CR) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xa, 0xd}, expected: [][]byte{{0xa}, {0xd}}, comment: "÷ [0.2] (LF) ÷ [4.0] (CR) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xd}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xa, 0xa}, expected: [][]byte{{0xa}, {0xa}}, comment: "÷ [0.2] (LF) ÷ [4.0] (LF) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xa}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x80}, expected: [][]byte{{0xa}, {0xcc, 0x80}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xa, 0xc2, 0xad}, expected: [][]byte{{0xa}, {0xc2, 0xad}}, comment: "÷ [0.2] (LF) ÷ [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xa, 0xc2, 0x85}, expected: [][]byte{{0xa}, {0xc2, 0x85}}, comment: "÷ [0.2] (LF) ÷ [4.0] (Sep) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xa, 0x9}, expected: [][]byte{{0xa}, {0x9}}, comment: "÷ [0.2] (LF) ÷ [4.0] (Sp) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x9}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x9}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xa, 0x61}, expected: [][]byte{{0xa}, {0x61}}, comment: "÷ [0.2] (LF) ÷ [4.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x61}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x61}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xa, 0x41}, expected: [][]byte{{0xa}, {0x41}}, comment: "÷ [0.2] (LF) ÷ [4.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x41}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xa, 0xc6, 0xbb}, expected: [][]byte{{0xa}, {0xc6, 0xbb}}, comment: "÷ [0.2] (LF) ÷ [4.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xa, 0x30}, expected: [][]byte{{0xa}, {0x30}}, comment: "÷ [0.2] (LF) ÷ [4.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x30}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xa, 0x2e}, expected: [][]byte{{0xa}, {0x2e}}, comment: "÷ [0.2] (LF) ÷ [4.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xa, 0x21}, expected: [][]byte{{0xa}, {0x21}}, comment: "÷ [0.2] (LF) ÷ [4.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x21}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x21}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xa, 0x22}, expected: [][]byte{{0xa}, {0x22}}, comment: "÷ [0.2] (LF) ÷ [4.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x22}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xa, 0x2c}, expected: [][]byte{{0xa}, {0x2c}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xa, 0x0}, expected: [][]byte{{0xa}, {0x0}}, comment: "÷ [0.2] (LF) ÷ [4.0] (XX) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0x0}}, comment: "÷ [0.2] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xd}, expected: [][]byte{{0xcc, 0x80, 0xd}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xa}, expected: [][]byte{{0xcc, 0x80, 0xa}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x80}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xc2, 0xad}, expected: [][]byte{{0xcc, 0x80, 0xc2, 0xad}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xc2, 0x85}, expected: [][]byte{{0xcc, 0x80, 0xc2, 0x85}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x9}, expected: [][]byte{{0xcc, 0x80, 0x9}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x9}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x61}, expected: [][]byte{{0xcc, 0x80, 0x61}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x61}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x41}, expected: [][]byte{{0xcc, 0x80, 0x41}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xc6, 0xbb}, expected: [][]byte{{0xcc, 0x80, 0xc6, 0xbb}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x30}, expected: [][]byte{{0xcc, 0x80, 0x30}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x2e}, expected: [][]byte{{0xcc, 0x80, 0x2e}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x21}, expected: [][]byte{{0xcc, 0x80, 0x21}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x21}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x22}, expected: [][]byte{{0xcc, 0x80, 0x22}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x2c}, expected: [][]byte{{0xcc, 0x80, 0x2c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x0}, expected: [][]byte{{0xcc, 0x80, 0x0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xd}, expected: [][]byte{{0xc2, 0xad, 0xd}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xa}, expected: [][]byte{{0xc2, 0xad, 0xa}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x80}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xc2, 0xad}, expected: [][]byte{{0xc2, 0xad, 0xc2, 0xad}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xc2, 0x85}, expected: [][]byte{{0xc2, 0xad, 0xc2, 0x85}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x9}, expected: [][]byte{{0xc2, 0xad, 0x9}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x9}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x61}, expected: [][]byte{{0xc2, 0xad, 0x61}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x61}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x41}, expected: [][]byte{{0xc2, 0xad, 0x41}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xc6, 0xbb}, expected: [][]byte{{0xc2, 0xad, 0xc6, 0xbb}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x30}, expected: [][]byte{{0xc2, 0xad, 0x30}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x2e}, expected: [][]byte{{0xc2, 0xad, 0x2e}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x21}, expected: [][]byte{{0xc2, 0xad, 0x21}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x21}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x22}, expected: [][]byte{{0xc2, 0xad, 0x22}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x2c}, expected: [][]byte{{0xc2, 0xad, 0x2c}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x0}, expected: [][]byte{{0xc2, 0xad, 0x0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xd}, expected: [][]byte{{0xc2, 0x85}, {0xd}}, comment: "÷ [0.2] (Sep) ÷ [4.0] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0xd}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xa}, expected: [][]byte{{0xc2, 0x85}, {0xa}}, comment: "÷ [0.2] (Sep) ÷ [4.0] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0xa}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x80}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xc2, 0xad}, expected: [][]byte{{0xc2, 0x85}, {0xc2, 0xad}}, comment: "÷ [0.2] (Sep) ÷ [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xc2, 0x85}, expected: [][]byte{{0xc2, 0x85}, {0xc2, 0x85}}, comment: "÷ [0.2] (Sep) ÷ [4.0] (Sep) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x9}, expected: [][]byte{{0xc2, 0x85}, {0x9}}, comment: "÷ [0.2] (Sep) ÷ [4.0] (Sp) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x9}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x9}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x61}, expected: [][]byte{{0xc2, 0x85}, {0x61}}, comment: "÷ [0.2] (Sep) ÷ [4.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x61}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x61}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x41}, expected: [][]byte{{0xc2, 0x85}, {0x41}}, comment: "÷ [0.2] (Sep) ÷ [4.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x41}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xc6, 0xbb}, expected: [][]byte{{0xc2, 0x85}, {0xc6, 0xbb}}, comment: "÷ [0.2] (Sep) ÷ [4.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x30}, expected: [][]byte{{0xc2, 0x85}, {0x30}}, comment: "÷ [0.2] (Sep) ÷ [4.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x30}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x2e}, expected: [][]byte{{0xc2, 0x85}, {0x2e}}, comment: "÷ [0.2] (Sep) ÷ [4.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x21}, expected: [][]byte{{0xc2, 0x85}, {0x21}}, comment: "÷ [0.2] (Sep) ÷ [4.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x21}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x21}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x22}, expected: [][]byte{{0xc2, 0x85}, {0x22}}, comment: "÷ [0.2] (Sep) ÷ [4.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x22}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x2c}, expected: [][]byte{{0xc2, 0x85}, {0x2c}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0x0}, expected: [][]byte{{0xc2, 0x85}, {0x0}}, comment: "÷ [0.2] (Sep) ÷ [4.0] (XX) ÷ [0.3]", }, { input: []byte{0xc2, 0x85, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xc2, 0x85}, {0xcc, 0x88, 0x0}}, comment: "÷ [0.2] (Sep) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x9, 0xd}, expected: [][]byte{{0x9, 0xd}}, comment: "÷ [0.2] (Sp) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x9, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x9, 0xa}, expected: [][]byte{{0x9, 0xa}}, comment: "÷ [0.2] (Sp) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x9, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x80}, expected: [][]byte{{0x9, 0xcc, 0x80}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x9, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x9, 0xc2, 0xad}, expected: [][]byte{{0x9, 0xc2, 0xad}}, comment: "÷ [0.2] (Sp) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x9, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x9, 0xc2, 0x85}, expected: [][]byte{{0x9, 0xc2, 0x85}}, comment: "÷ [0.2] (Sp) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x9, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x9, 0x9}, expected: [][]byte{{0x9, 0x9}}, comment: "÷ [0.2] (Sp) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x9, 0x61}, expected: [][]byte{{0x9, 0x61}}, comment: "÷ [0.2] (Sp) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x9, 0x41}, expected: [][]byte{{0x9, 0x41}}, comment: "÷ [0.2] (Sp) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x9, 0xc6, 0xbb}, expected: [][]byte{{0x9, 0xc6, 0xbb}}, comment: "÷ [0.2] (Sp) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x9, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x9, 0x30}, expected: [][]byte{{0x9, 0x30}}, comment: "÷ [0.2] (Sp) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x9, 0x2e}, expected: [][]byte{{0x9, 0x2e}}, comment: "÷ [0.2] (Sp) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x9, 0x21}, expected: [][]byte{{0x9, 0x21}}, comment: "÷ [0.2] (Sp) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x9, 0x22}, expected: [][]byte{{0x9, 0x22}}, comment: "÷ [0.2] (Sp) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x9, 0x2c}, expected: [][]byte{{0x9, 0x2c}}, comment: "÷ [0.2] (Sp) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x9, 0x0}, expected: [][]byte{{0x9, 0x0}}, comment: "÷ [0.2] (Sp) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x9, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x9, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x61, 0xd}, expected: [][]byte{{0x61, 0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x61, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0xa}, expected: [][]byte{{0x61, 0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x61, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x80}, expected: [][]byte{{0x61, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x61, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0xc2, 0xad}, expected: [][]byte{{0x61, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x61, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xc2, 0x85}, expected: [][]byte{{0x61, 0xc2, 0x85}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x61, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x61, 0x9}, expected: [][]byte{{0x61, 0x9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x61, 0x61}, expected: [][]byte{{0x61, 0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x61, 0x41}, expected: [][]byte{{0x61, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x61, 0xc6, 0xbb}, expected: [][]byte{{0x61, 0xc6, 0xbb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x61, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x30}, expected: [][]byte{{0x61, 0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2e}, expected: [][]byte{{0x61, 0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x61, 0x21}, expected: [][]byte{{0x61, 0x21}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x61, 0x22}, expected: [][]byte{{0x61, 0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x61, 0x2c}, expected: [][]byte{{0x61, 0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x61, 0x0}, expected: [][]byte{{0x61, 0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x61, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x41, 0xd}, expected: [][]byte{{0x41, 0xd}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x41, 0xa}, expected: [][]byte{{0x41, 0xa}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x80}, expected: [][]byte{{0x41, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x41, 0xc2, 0xad}, expected: [][]byte{{0x41, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x41, 0xc2, 0x85}, expected: [][]byte{{0x41, 0xc2, 0x85}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x41, 0x9}, expected: [][]byte{{0x41, 0x9}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x41, 0x61}, expected: [][]byte{{0x41, 0x61}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x41, 0x41}, expected: [][]byte{{0x41, 0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x41, 0xc6, 0xbb}, expected: [][]byte{{0x41, 0xc6, 0xbb}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x41, 0x30}, expected: [][]byte{{0x41, 0x30}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x41, 0x2e}, expected: [][]byte{{0x41, 0x2e}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x41, 0x21}, expected: [][]byte{{0x41, 0x21}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x41, 0x22}, expected: [][]byte{{0x41, 0x22}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x41, 0x2c}, expected: [][]byte{{0x41, 0x2c}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x41, 0x0}, expected: [][]byte{{0x41, 0x0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xd}, expected: [][]byte{{0xc6, 0xbb, 0xd}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xa}, expected: [][]byte{{0xc6, 0xbb, 0xa}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x80}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xc2, 0xad}, expected: [][]byte{{0xc6, 0xbb, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xc2, 0x85}, expected: [][]byte{{0xc6, 0xbb, 0xc2, 0x85}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x9}, expected: [][]byte{{0xc6, 0xbb, 0x9}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x9}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x61}, expected: [][]byte{{0xc6, 0xbb, 0x61}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x61}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x41}, expected: [][]byte{{0xc6, 0xbb, 0x41}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xc6, 0xbb}, expected: [][]byte{{0xc6, 0xbb, 0xc6, 0xbb}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x30}, expected: [][]byte{{0xc6, 0xbb, 0x30}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x2e}, expected: [][]byte{{0xc6, 0xbb, 0x2e}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x21}, expected: [][]byte{{0xc6, 0xbb, 0x21}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x21}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x22}, expected: [][]byte{{0xc6, 0xbb, 0x22}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x2c}, expected: [][]byte{{0xc6, 0xbb, 0x2c}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0x0}, expected: [][]byte{{0xc6, 0xbb, 0x0}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xc6, 0xbb, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xc6, 0xbb, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] LATIN LETTER TWO WITH STROKE (OLetter) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x30, 0xd}, expected: [][]byte{{0x30, 0xd}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x30, 0xa}, expected: [][]byte{{0x30, 0xa}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x80}, expected: [][]byte{{0x30, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x30, 0xc2, 0xad}, expected: [][]byte{{0x30, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x30, 0xc2, 0x85}, expected: [][]byte{{0x30, 0xc2, 0x85}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x30, 0x9}, expected: [][]byte{{0x30, 0x9}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x30, 0x61}, expected: [][]byte{{0x30, 0x61}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x30, 0x41}, expected: [][]byte{{0x30, 0x41}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x30, 0xc6, 0xbb}, expected: [][]byte{{0x30, 0xc6, 0xbb}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x30, 0x30}, expected: [][]byte{{0x30, 0x30}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x30, 0x2e}, expected: [][]byte{{0x30, 0x2e}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x30, 0x21}, expected: [][]byte{{0x30, 0x21}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x30, 0x22}, expected: [][]byte{{0x30, 0x22}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x30, 0x2c}, expected: [][]byte{{0x30, 0x2c}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x30, 0x0}, expected: [][]byte{{0x30, 0x0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x2e, 0xd}, expected: [][]byte{{0x2e, 0xd}}, comment: "÷ [0.2] FULL STOP (ATerm) × [9.0] (CR) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] (CR) ÷ [0.3]", }, { input: []byte{0x2e, 0xa}, expected: [][]byte{{0x2e, 0xa}}, comment: "÷ [0.2] FULL STOP (ATerm) × [9.0] (LF) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] (LF) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x80}, expected: [][]byte{{0x2e, 0xcc, 0x80}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x2e, 0xc2, 0xad}, expected: [][]byte{{0x2e, 0xc2, 0xad}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0xc2, 0x85}, expected: [][]byte{{0x2e, 0xc2, 0x85}}, comment: "÷ [0.2] FULL STOP (ATerm) × [9.0] (Sep) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] (Sep) ÷ [0.3]", }, { input: []byte{0x2e, 0x9}, expected: [][]byte{{0x2e, 0x9}}, comment: "÷ [0.2] FULL STOP (ATerm) × [9.0] (Sp) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] (Sp) ÷ [0.3]", }, { input: []byte{0x2e, 0x61}, expected: [][]byte{{0x2e, 0x61}}, comment: "÷ [0.2] FULL STOP (ATerm) × [8.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [8.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x2e, 0x41}, expected: [][]byte{{0x2e}, {0x41}}, comment: "÷ [0.2] FULL STOP (ATerm) ÷ [11.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x2e, 0xc6, 0xbb}, expected: [][]byte{{0x2e}, {0xc6, 0xbb}}, comment: "÷ [0.2] FULL STOP (ATerm) ÷ [11.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xc6, 0xbb}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x2e, 0x30}, expected: [][]byte{{0x2e, 0x30}}, comment: "÷ [0.2] FULL STOP (ATerm) × [6.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [6.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x2e, 0x2e}, expected: [][]byte{{0x2e, 0x2e}}, comment: "÷ [0.2] FULL STOP (ATerm) × [8.1] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [8.1] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x2e, 0x21}, expected: [][]byte{{0x2e, 0x21}}, comment: "÷ [0.2] FULL STOP (ATerm) × [8.1] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [8.1] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x2e, 0x22}, expected: [][]byte{{0x2e, 0x22}}, comment: "÷ [0.2] FULL STOP (ATerm) × [9.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x2e, 0x2c}, expected: [][]byte{{0x2e, 0x2c}}, comment: "÷ [0.2] FULL STOP (ATerm) × [8.1] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) × [8.1] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x2e, 0x0}, expected: [][]byte{{0x2e}, {0x0}}, comment: "÷ [0.2] FULL STOP (ATerm) ÷ [11.0] (XX) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] FULL STOP (ATerm) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] (XX) ÷ [0.3]", }, { input: []byte{0x21, 0xd}, expected: [][]byte{{0x21, 0xd}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [9.0] (CR) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x21, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] (CR) ÷ [0.3]", }, { input: []byte{0x21, 0xa}, expected: [][]byte{{0x21, 0xa}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [9.0] (LF) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x21, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] (LF) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x80}, expected: [][]byte{{0x21, 0xcc, 0x80}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x21, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x21, 0xc2, 0xad}, expected: [][]byte{{0x21, 0xc2, 0xad}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x21, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x21, 0xc2, 0x85}, expected: [][]byte{{0x21, 0xc2, 0x85}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [9.0] (Sep) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x21, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] (Sep) ÷ [0.3]", }, { input: []byte{0x21, 0x9}, expected: [][]byte{{0x21, 0x9}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [9.0] (Sp) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x21, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] (Sp) ÷ [0.3]", }, { input: []byte{0x21, 0x61}, expected: [][]byte{{0x21}, {0x61}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) ÷ [11.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x21, 0xcc, 0x88}, {0x61}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x21, 0x41}, expected: [][]byte{{0x21}, {0x41}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) ÷ [11.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x21, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x21, 0xc6, 0xbb}, expected: [][]byte{{0x21}, {0xc6, 0xbb}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) ÷ [11.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x21, 0xcc, 0x88}, {0xc6, 0xbb}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x21, 0x30}, expected: [][]byte{{0x21}, {0x30}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) ÷ [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x21, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x21, 0x2e}, expected: [][]byte{{0x21, 0x2e}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [8.1] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x21, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [8.1] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x21, 0x21}, expected: [][]byte{{0x21, 0x21}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [8.1] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x21, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [8.1] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x21, 0x22}, expected: [][]byte{{0x21, 0x22}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [9.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x21, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [9.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x21, 0x2c}, expected: [][]byte{{0x21, 0x2c}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [8.1] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x21, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) × [8.1] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x21, 0x0}, expected: [][]byte{{0x21}, {0x0}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) ÷ [11.0] (XX) ÷ [0.3]", }, { input: []byte{0x21, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x21, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] (XX) ÷ [0.3]", }, { input: []byte{0x22, 0xd}, expected: [][]byte{{0x22, 0xd}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x22, 0xa}, expected: [][]byte{{0x22, 0xa}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x80}, expected: [][]byte{{0x22, 0xcc, 0x80}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x22, 0xc2, 0xad}, expected: [][]byte{{0x22, 0xc2, 0xad}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x22, 0xc2, 0x85}, expected: [][]byte{{0x22, 0xc2, 0x85}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x22, 0x9}, expected: [][]byte{{0x22, 0x9}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x22, 0x61}, expected: [][]byte{{0x22, 0x61}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x22, 0x41}, expected: [][]byte{{0x22, 0x41}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x22, 0xc6, 0xbb}, expected: [][]byte{{0x22, 0xc6, 0xbb}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x22, 0x30}, expected: [][]byte{{0x22, 0x30}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x22, 0x2e}, expected: [][]byte{{0x22, 0x2e}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x22, 0x21}, expected: [][]byte{{0x22, 0x21}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x22, 0x22}, expected: [][]byte{{0x22, 0x22}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x22, 0x2c}, expected: [][]byte{{0x22, 0x2c}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x22, 0x0}, expected: [][]byte{{0x22, 0x0}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x22, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x2c, 0xd}, expected: [][]byte{{0x2c, 0xd}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x2c, 0xa}, expected: [][]byte{{0x2c, 0xa}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x80}, expected: [][]byte{{0x2c, 0xcc, 0x80}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x2c, 0xc2, 0xad}, expected: [][]byte{{0x2c, 0xc2, 0xad}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0xc2, 0x85}, expected: [][]byte{{0x2c, 0xc2, 0x85}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x2c, 0x9}, expected: [][]byte{{0x2c, 0x9}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x2c, 0x61}, expected: [][]byte{{0x2c, 0x61}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x2c, 0x41}, expected: [][]byte{{0x2c, 0x41}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x2c, 0xc6, 0xbb}, expected: [][]byte{{0x2c, 0xc6, 0xbb}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x2c, 0x30}, expected: [][]byte{{0x2c, 0x30}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x2c, 0x2e}, expected: [][]byte{{0x2c, 0x2e}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x2c, 0x21}, expected: [][]byte{{0x2c, 0x21}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x2c, 0x22}, expected: [][]byte{{0x2c, 0x22}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x2c, 0x2c}, expected: [][]byte{{0x2c, 0x2c}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x2c, 0x0}, expected: [][]byte{{0x2c, 0x0}}, comment: "÷ [0.2] COMMA (SContinue) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] COMMA (SContinue) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x0, 0xd}, expected: [][]byte{{0x0, 0xd}}, comment: "÷ [0.2] (XX) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xd}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (CR) ÷ [0.3]", }, { input: []byte{0x0, 0xa}, expected: [][]byte{{0x0, 0xa}}, comment: "÷ [0.2] (XX) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xa}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (LF) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x80}, expected: [][]byte{{0x0, 0xcc, 0x80}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x0, 0xc2, 0xad}, expected: [][]byte{{0x0, 0xc2, 0xad}}, comment: "÷ [0.2] (XX) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x0, 0xc2, 0x85}, expected: [][]byte{{0x0, 0xc2, 0x85}}, comment: "÷ [0.2] (XX) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xc2, 0x85}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xc2, 0x85}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sep) ÷ [0.3]", }, { input: []byte{0x0, 0x9}, expected: [][]byte{{0x0, 0x9}}, comment: "÷ [0.2] (XX) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x9}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x9}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (Sp) ÷ [0.3]", }, { input: []byte{0x0, 0x61}, expected: [][]byte{{0x0, 0x61}}, comment: "÷ [0.2] (XX) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x61}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x61}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x0, 0x41}, expected: [][]byte{{0x0, 0x41}}, comment: "÷ [0.2] (XX) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0x0, 0xc6, 0xbb}, expected: [][]byte{{0x0, 0xc6, 0xbb}}, comment: "÷ [0.2] (XX) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xc6, 0xbb}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xc6, 0xbb}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN LETTER TWO WITH STROKE (OLetter) ÷ [0.3]", }, { input: []byte{0x0, 0x30}, expected: [][]byte{{0x0, 0x30}}, comment: "÷ [0.2] (XX) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x0, 0x2e}, expected: [][]byte{{0x0, 0x2e}}, comment: "÷ [0.2] (XX) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x2e}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x0, 0x21}, expected: [][]byte{{0x0, 0x21}}, comment: "÷ [0.2] (XX) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x21}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x21}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] EXCLAMATION MARK (STerm) ÷ [0.3]", }, { input: []byte{0x0, 0x22}, expected: [][]byte{{0x0, 0x22}}, comment: "÷ [0.2] (XX) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x22}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] QUOTATION MARK (Close) ÷ [0.3]", }, { input: []byte{0x0, 0x2c}, expected: [][]byte{{0x0, 0x2c}}, comment: "÷ [0.2] (XX) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x2c}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] COMMA (SContinue) ÷ [0.3]", }, { input: []byte{0x0, 0x0}, expected: [][]byte{{0x0, 0x0}}, comment: "÷ [0.2] (XX) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x0, 0xcc, 0x88, 0x0}}, comment: "÷ [0.2] (XX) × [5.0] COMBINING DIAERESIS (Extend) × [998.0] (XX) ÷ [0.3]", }, { input: []byte{0xd, 0xa, 0x61, 0xa, 0xcc, 0x88}, expected: [][]byte{{0xd, 0xa}, {0x61, 0xa}, {0xcc, 0x88}}, comment: "÷ [0.2] (CR) × [3.0] (LF) ÷ [4.0] LATIN SMALL LETTER A (Lower) × [998.0] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88}, expected: [][]byte{{0x61, 0xcc, 0x88}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [5.0] COMBINING DIAERESIS (Extend) ÷ [0.3]", }, { input: []byte{0x20, 0xe2, 0x80, 0x8d, 0xd9, 0x86}, expected: [][]byte{{0x20, 0xe2, 0x80, 0x8d, 0xd9, 0x86}}, comment: "÷ [0.2] SPACE (Sp) × [5.0] ZERO WIDTH JOINER (Extend) × [998.0] ARABIC LETTER NOON (OLetter) ÷ [0.3]", }, { input: []byte{0xd9, 0x86, 0xe2, 0x80, 0x8d, 0x20}, expected: [][]byte{{0xd9, 0x86, 0xe2, 0x80, 0x8d, 0x20}}, comment: "÷ [0.2] ARABIC LETTER NOON (OLetter) × [5.0] ZERO WIDTH JOINER (Extend) × [998.0] SPACE (Sp) ÷ [0.3]", }, { input: []byte{0x28, 0x22, 0x47, 0x6f, 0x2e, 0x22, 0x29, 0x20, 0x28, 0x48, 0x65, 0x20, 0x64, 0x69, 0x64, 0x2e, 0x29}, expected: [][]byte{{0x28, 0x22, 0x47, 0x6f, 0x2e, 0x22, 0x29, 0x20}, {0x28, 0x48, 0x65, 0x20, 0x64, 0x69, 0x64, 0x2e, 0x29}}, comment: "÷ [0.2] LEFT PARENTHESIS (Close) × [998.0] QUOTATION MARK (Close) × [998.0] LATIN CAPITAL LETTER G (Upper) × [998.0] LATIN SMALL LETTER O (Lower) × [998.0] FULL STOP (ATerm) × [9.0] QUOTATION MARK (Close) × [9.0] RIGHT PARENTHESIS (Close) × [9.0] SPACE (Sp) ÷ [11.0] LEFT PARENTHESIS (Close) × [998.0] LATIN CAPITAL LETTER H (Upper) × [998.0] LATIN SMALL LETTER E (Lower) × [998.0] SPACE (Sp) × [998.0] LATIN SMALL LETTER D (Lower) × [998.0] LATIN SMALL LETTER I (Lower) × [998.0] LATIN SMALL LETTER D (Lower) × [998.0] FULL STOP (ATerm) × [9.0] RIGHT PARENTHESIS (Close) ÷ [0.3]", }, { input: []byte{0x28, 0xe2, 0x80, 0x9c, 0x47, 0x6f, 0x3f, 0xe2, 0x80, 0x9d, 0x29, 0x20, 0x28, 0x48, 0x65, 0x20, 0x64, 0x69, 0x64, 0x2e, 0x29}, expected: [][]byte{{0x28, 0xe2, 0x80, 0x9c, 0x47, 0x6f, 0x3f, 0xe2, 0x80, 0x9d, 0x29, 0x20}, {0x28, 0x48, 0x65, 0x20, 0x64, 0x69, 0x64, 0x2e, 0x29}}, comment: "÷ [0.2] LEFT PARENTHESIS (Close) × [998.0] LEFT DOUBLE QUOTATION MARK (Close) × [998.0] LATIN CAPITAL LETTER G (Upper) × [998.0] LATIN SMALL LETTER O (Lower) × [998.0] QUESTION MARK (STerm) × [9.0] RIGHT DOUBLE QUOTATION MARK (Close) × [9.0] RIGHT PARENTHESIS (Close) × [9.0] SPACE (Sp) ÷ [11.0] LEFT PARENTHESIS (Close) × [998.0] LATIN CAPITAL LETTER H (Upper) × [998.0] LATIN SMALL LETTER E (Lower) × [998.0] SPACE (Sp) × [998.0] LATIN SMALL LETTER D (Lower) × [998.0] LATIN SMALL LETTER I (Lower) × [998.0] LATIN SMALL LETTER D (Lower) × [998.0] FULL STOP (ATerm) × [9.0] RIGHT PARENTHESIS (Close) ÷ [0.3]", }, { input: []byte{0x55, 0x2e, 0x53, 0x2e, 0x41, 0xcc, 0x80, 0x2e, 0x20, 0x69, 0x73}, expected: [][]byte{{0x55, 0x2e, 0x53, 0x2e, 0x41, 0xcc, 0x80, 0x2e, 0x20, 0x69, 0x73}}, comment: "÷ [0.2] LATIN CAPITAL LETTER U (Upper) × [998.0] FULL STOP (ATerm) × [7.0] LATIN CAPITAL LETTER S (Upper) × [998.0] FULL STOP (ATerm) × [7.0] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING GRAVE ACCENT (Extend) × [998.0] FULL STOP (ATerm) × [8.0] SPACE (Sp) × [8.0] LATIN SMALL LETTER I (Lower) × [998.0] LATIN SMALL LETTER S (Lower) ÷ [0.3]", }, { input: []byte{0x55, 0x2e, 0x53, 0x2e, 0x41, 0xcc, 0x80, 0x3f, 0x20, 0x48, 0x65}, expected: [][]byte{{0x55, 0x2e, 0x53, 0x2e, 0x41, 0xcc, 0x80, 0x3f, 0x20}, {0x48, 0x65}}, comment: "÷ [0.2] LATIN CAPITAL LETTER U (Upper) × [998.0] FULL STOP (ATerm) × [7.0] LATIN CAPITAL LETTER S (Upper) × [998.0] FULL STOP (ATerm) × [7.0] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING GRAVE ACCENT (Extend) × [998.0] QUESTION MARK (STerm) × [9.0] SPACE (Sp) ÷ [11.0] LATIN CAPITAL LETTER H (Upper) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x55, 0x2e, 0x53, 0x2e, 0x41, 0xcc, 0x80, 0x2e}, expected: [][]byte{{0x55, 0x2e, 0x53, 0x2e, 0x41, 0xcc, 0x80, 0x2e}}, comment: "÷ [0.2] LATIN CAPITAL LETTER U (Upper) × [998.0] FULL STOP (ATerm) × [7.0] LATIN CAPITAL LETTER S (Upper) × [998.0] FULL STOP (ATerm) × [7.0] LATIN CAPITAL LETTER A (Upper) × [5.0] COMBINING GRAVE ACCENT (Extend) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x33, 0x2e, 0x34}, expected: [][]byte{{0x33, 0x2e, 0x34}}, comment: "÷ [0.2] DIGIT THREE (Numeric) × [998.0] FULL STOP (ATerm) × [6.0] DIGIT FOUR (Numeric) ÷ [0.3]", }, { input: []byte{0x63, 0x2e, 0x64}, expected: [][]byte{{0x63, 0x2e, 0x64}}, comment: "÷ [0.2] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [8.0] LATIN SMALL LETTER D (Lower) ÷ [0.3]", }, { input: []byte{0x43, 0x2e, 0x64}, expected: [][]byte{{0x43, 0x2e, 0x64}}, comment: "÷ [0.2] LATIN CAPITAL LETTER C (Upper) × [998.0] FULL STOP (ATerm) × [8.0] LATIN SMALL LETTER D (Lower) ÷ [0.3]", }, { input: []byte{0x63, 0x2e, 0x44}, expected: [][]byte{{0x63, 0x2e, 0x44}}, comment: "÷ [0.2] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [7.0] LATIN CAPITAL LETTER D (Upper) ÷ [0.3]", }, { input: []byte{0x43, 0x2e, 0x44}, expected: [][]byte{{0x43, 0x2e, 0x44}}, comment: "÷ [0.2] LATIN CAPITAL LETTER C (Upper) × [998.0] FULL STOP (ATerm) × [7.0] LATIN CAPITAL LETTER D (Upper) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0x74, 0x68, 0x65}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0x74, 0x68, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [8.0] RIGHT PARENTHESIS (Close) × [8.0] RIGHT SINGLE QUOTATION MARK (Close) × [8.0] NO-BREAK SPACE (Sp) × [8.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0x54, 0x68, 0x65}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0}, {0x54, 0x68, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [9.0] RIGHT PARENTHESIS (Close) × [9.0] RIGHT SINGLE QUOTATION MARK (Close) × [9.0] NO-BREAK SPACE (Sp) ÷ [11.0] LATIN CAPITAL LETTER T (Upper) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0xe2, 0x80, 0x98, 0x28, 0x74, 0x68, 0x65}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0xe2, 0x80, 0x98, 0x28, 0x74, 0x68, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [8.0] RIGHT PARENTHESIS (Close) × [8.0] RIGHT SINGLE QUOTATION MARK (Close) × [8.0] NO-BREAK SPACE (Sp) × [8.0] LEFT SINGLE QUOTATION MARK (Close) × [998.0] LEFT PARENTHESIS (Close) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0xe2, 0x80, 0x98, 0x28, 0x54, 0x68, 0x65}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0}, {0xe2, 0x80, 0x98, 0x28, 0x54, 0x68, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [9.0] RIGHT PARENTHESIS (Close) × [9.0] RIGHT SINGLE QUOTATION MARK (Close) × [9.0] NO-BREAK SPACE (Sp) ÷ [11.0] LEFT SINGLE QUOTATION MARK (Close) × [998.0] LEFT PARENTHESIS (Close) × [998.0] LATIN CAPITAL LETTER T (Upper) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0xcc, 0x88, 0x74, 0x68, 0x65}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0xcc, 0x88, 0x74, 0x68, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [8.0] RIGHT PARENTHESIS (Close) × [8.0] RIGHT SINGLE QUOTATION MARK (Close) × [8.0] NO-BREAK SPACE (Sp) × [5.0] COMBINING DIAERESIS (Extend) × [8.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0xcc, 0x88, 0x54, 0x68, 0x65}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xc2, 0xa0, 0xcc, 0x88}, {0x54, 0x68, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [9.0] RIGHT PARENTHESIS (Close) × [9.0] RIGHT SINGLE QUOTATION MARK (Close) × [9.0] NO-BREAK SPACE (Sp) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN CAPITAL LETTER T (Upper) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xcc, 0x88, 0x54, 0x68, 0x65}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0x29, 0xe2, 0x80, 0x99, 0xcc, 0x88}, {0x54, 0x68, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [9.0] RIGHT PARENTHESIS (Close) × [9.0] RIGHT SINGLE QUOTATION MARK (Close) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN CAPITAL LETTER T (Upper) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0x29, 0xa, 0xcc, 0x88, 0x54, 0x68, 0x65}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0x29, 0xa}, {0xcc, 0x88, 0x54, 0x68, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [9.0] RIGHT PARENTHESIS (Close) × [9.0] (LF) ÷ [4.0] COMBINING DIAERESIS (Extend) × [998.0] LATIN CAPITAL LETTER T (Upper) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x2e, 0x20, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65}, expected: [][]byte{{0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x2e, 0x20, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65}}, comment: "÷ [0.2] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER H (Lower) × [998.0] LATIN SMALL LETTER E (Lower) × [998.0] SPACE (Sp) × [998.0] LATIN SMALL LETTER R (Lower) × [998.0] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER S (Lower) × [998.0] LATIN SMALL LETTER P (Lower) × [998.0] FULL STOP (ATerm) × [8.0] SPACE (Sp) × [8.0] LATIN SMALL LETTER L (Lower) × [998.0] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER A (Lower) × [998.0] LATIN SMALL LETTER D (Lower) × [998.0] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER R (Lower) × [998.0] LATIN SMALL LETTER S (Lower) × [998.0] SPACE (Sp) × [998.0] LATIN SMALL LETTER A (Lower) × [998.0] LATIN SMALL LETTER R (Lower) × [998.0] LATIN SMALL LETTER E (Lower) ÷ [0.3]", }, { input: []byte{0xe5, 0xad, 0x97, 0x2e, 0xe5, 0xad, 0x97}, expected: [][]byte{{0xe5, 0xad, 0x97, 0x2e}, {0xe5, 0xad, 0x97}}, comment: "÷ [0.2] CJK UNIFIED IDEOGRAPH-5B57 (OLetter) × [998.0] FULL STOP (ATerm) ÷ [11.0] CJK UNIFIED IDEOGRAPH-5B57 (OLetter) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0xe5, 0xae, 0x83}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e}, {0xe5, 0xae, 0x83}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) ÷ [11.0] CJK UNIFIED IDEOGRAPH-5B83 (OLetter) ÷ [0.3]", }, { input: []byte{0x65, 0x74, 0x63, 0x2e, 0xe3, 0x80, 0x82}, expected: [][]byte{{0x65, 0x74, 0x63, 0x2e, 0xe3, 0x80, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER E (Lower) × [998.0] LATIN SMALL LETTER T (Lower) × [998.0] LATIN SMALL LETTER C (Lower) × [998.0] FULL STOP (ATerm) × [8.1] IDEOGRAPHIC FULL STOP (STerm) ÷ [0.3]", }, { input: []byte{0xe5, 0xad, 0x97, 0xe3, 0x80, 0x82, 0xe5, 0xae, 0x83}, expected: [][]byte{{0xe5, 0xad, 0x97, 0xe3, 0x80, 0x82}, {0xe5, 0xae, 0x83}}, comment: "÷ [0.2] CJK UNIFIED IDEOGRAPH-5B57 (OLetter) × [998.0] IDEOGRAPHIC FULL STOP (STerm) ÷ [11.0] CJK UNIFIED IDEOGRAPH-5B83 (OLetter) ÷ [0.3]", }, { input: []byte{0x21, 0x20, 0x20}, expected: [][]byte{{0x21, 0x20, 0x20}}, comment: "÷ [0.2] EXCLAMATION MARK (STerm) × [9.0] SPACE (Sp) × [10.0] SPACE (Sp) ÷ [0.3]", }, { input: []byte{0x61, 0x2e}, expected: [][]byte{{0x61, 0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] FULL STOP (ATerm) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0xd, 0xa}, expected: [][]byte{{0x61, 0x2e, 0xd, 0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] FULL STOP (ATerm) × [9.0] (CR) × [3.0] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0xd, 0xa, 0x20}, expected: [][]byte{{0x61, 0x2e, 0xd, 0xa}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] FULL STOP (ATerm) × [9.0] (CR) × [3.0] (LF) ÷ [4.0] SPACE (Sp) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0xd, 0xa, 0x61}, expected: [][]byte{{0x61, 0x2e, 0xd, 0xa}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (Lower) × [998.0] FULL STOP (ATerm) × [9.0] (CR) × [3.0] (LF) ÷ [4.0] LATIN SMALL LETTER A (Lower) ÷ [0.3]", }, { input: []byte{0x41, 0x2e, 0xd, 0xa, 0x41}, expected: [][]byte{{0x41, 0x2e, 0xd, 0xa}, {0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (Upper) × [998.0] FULL STOP (ATerm) × [9.0] (CR) × [3.0] (LF) ÷ [4.0] LATIN CAPITAL LETTER A (Upper) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0x22, 0xe2, 0x81, 0xa0, 0x47, 0xe2, 0x81, 0xa0, 0x6f, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x22, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0x48, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x69, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0x22, 0xe2, 0x81, 0xa0, 0x47, 0xe2, 0x81, 0xa0, 0x6f, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x22, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0}, {0x28, 0xe2, 0x81, 0xa0, 0x48, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x69, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LEFT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [998.0] QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER G (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER O (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [9.0] SPACE (Sp) × [5.0] WORD JOINER (Format) ÷ [11.0] LEFT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER H (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER D (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER I (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER D (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x9c, 0xe2, 0x81, 0xa0, 0x47, 0xe2, 0x81, 0xa0, 0x6f, 0xe2, 0x81, 0xa0, 0x3f, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x9d, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0x48, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x69, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x9c, 0xe2, 0x81, 0xa0, 0x47, 0xe2, 0x81, 0xa0, 0x6f, 0xe2, 0x81, 0xa0, 0x3f, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x9d, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0}, {0x28, 0xe2, 0x81, 0xa0, 0x48, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x69, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LEFT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [998.0] LEFT DOUBLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER G (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER O (Lower) × [5.0] WORD JOINER (Format) × [998.0] QUESTION MARK (STerm) × [5.0] WORD JOINER (Format) × [9.0] RIGHT DOUBLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [9.0] SPACE (Sp) × [5.0] WORD JOINER (Format) ÷ [11.0] LEFT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER H (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER D (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER I (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER D (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x55, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x53, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x41, 0xe2, 0x81, 0xa0, 0xcc, 0x80, 0x2e, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x69, 0xe2, 0x81, 0xa0, 0x73, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x55, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x53, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x41, 0xe2, 0x81, 0xa0, 0xcc, 0x80, 0x2e, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x69, 0xe2, 0x81, 0xa0, 0x73, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER U (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER S (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER A (Upper) × [5.0] WORD JOINER (Format) × [5.0] COMBINING GRAVE ACCENT (Extend) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [8.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [8.0] LATIN SMALL LETTER I (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER S (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x55, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x53, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x41, 0xe2, 0x81, 0xa0, 0xcc, 0x80, 0x3f, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x48, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x55, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x53, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x41, 0xe2, 0x81, 0xa0, 0xcc, 0x80, 0x3f, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0}, {0x48, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER U (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER S (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER A (Upper) × [5.0] WORD JOINER (Format) × [5.0] COMBINING GRAVE ACCENT (Extend) × [998.0] QUESTION MARK (STerm) × [5.0] WORD JOINER (Format) × [9.0] SPACE (Sp) × [5.0] WORD JOINER (Format) ÷ [11.0] LATIN CAPITAL LETTER H (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x55, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x53, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x41, 0xe2, 0x81, 0xa0, 0xcc, 0x80, 0x2e, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x55, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x53, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x41, 0xe2, 0x81, 0xa0, 0xcc, 0x80, 0x2e, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER U (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER S (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER A (Upper) × [5.0] WORD JOINER (Format) × [5.0] COMBINING GRAVE ACCENT (Extend) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x33, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x34, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x33, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x34, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] DIGIT THREE (Numeric) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [6.0] DIGIT FOUR (Numeric) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [8.0] LATIN SMALL LETTER D (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x43, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x43, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER C (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [8.0] LATIN SMALL LETTER D (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x44, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x44, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER D (Upper) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x43, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x44, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x43, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x44, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER C (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER D (Upper) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [8.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [8.0] RIGHT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [8.0] NO-BREAK SPACE (Sp) × [5.0] WORD JOINER (Format) × [8.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0}, {0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [9.0] RIGHT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [9.0] NO-BREAK SPACE (Sp) × [5.0] WORD JOINER (Format) ÷ [11.0] LATIN CAPITAL LETTER T (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x98, 0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x98, 0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [8.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [8.0] RIGHT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [8.0] NO-BREAK SPACE (Sp) × [5.0] WORD JOINER (Format) × [8.0] LEFT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [998.0] LEFT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x98, 0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0}, {0xe2, 0x80, 0x98, 0xe2, 0x81, 0xa0, 0x28, 0xe2, 0x81, 0xa0, 0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [9.0] RIGHT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [9.0] NO-BREAK SPACE (Sp) × [5.0] WORD JOINER (Format) ÷ [11.0] LEFT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [998.0] LEFT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER T (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x74, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x74, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [8.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [8.0] RIGHT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [8.0] NO-BREAK SPACE (Sp) × [5.0] WORD JOINER (Format) × [5.0] COMBINING DIAERESIS (Extend) × [8.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xc2, 0xa0, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [9.0] RIGHT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [9.0] NO-BREAK SPACE (Sp) × [5.0] WORD JOINER (Format) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN CAPITAL LETTER T (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x99, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [9.0] RIGHT SINGLE QUOTATION MARK (Close) × [5.0] WORD JOINER (Format) × [5.0] COMBINING DIAERESIS (Extend) ÷ [11.0] LATIN CAPITAL LETTER T (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xa, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x81, 0xa0, 0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x29, 0xe2, 0x81, 0xa0, 0xa}, {0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x81, 0xa0, 0x54, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] RIGHT PARENTHESIS (Close) × [5.0] WORD JOINER (Format) × [9.0] (LF) ÷ [4.0] WORD JOINER (Format) × [5.0] COMBINING DIAERESIS (Extend) × [5.0] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER T (Upper) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x72, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x73, 0xe2, 0x81, 0xa0, 0x70, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x6c, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x72, 0xe2, 0x81, 0xa0, 0x73, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x72, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x68, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x72, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x73, 0xe2, 0x81, 0xa0, 0x70, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x6c, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x64, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x72, 0xe2, 0x81, 0xa0, 0x73, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x72, 0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER H (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER R (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER S (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER P (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [8.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [8.0] LATIN SMALL LETTER L (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER A (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER D (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER R (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER S (Lower) × [5.0] WORD JOINER (Format) × [998.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER A (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER R (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0xe5, 0xad, 0x97, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xe5, 0xad, 0x97, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0xe5, 0xad, 0x97, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0}, {0xe5, 0xad, 0x97, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] CJK UNIFIED IDEOGRAPH-5B57 (OLetter) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) ÷ [11.0] CJK UNIFIED IDEOGRAPH-5B57 (OLetter) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xe5, 0xae, 0x83, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0}, {0xe5, 0xae, 0x83, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) ÷ [11.0] CJK UNIFIED IDEOGRAPH-5B83 (OLetter) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xe3, 0x80, 0x82, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x65, 0xe2, 0x81, 0xa0, 0x74, 0xe2, 0x81, 0xa0, 0x63, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xe3, 0x80, 0x82, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER E (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER T (Lower) × [5.0] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER C (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [8.1] IDEOGRAPHIC FULL STOP (STerm) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0xe5, 0xad, 0x97, 0xe2, 0x81, 0xa0, 0xe3, 0x80, 0x82, 0xe2, 0x81, 0xa0, 0xe5, 0xae, 0x83, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0xe5, 0xad, 0x97, 0xe2, 0x81, 0xa0, 0xe3, 0x80, 0x82, 0xe2, 0x81, 0xa0}, {0xe5, 0xae, 0x83, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] CJK UNIFIED IDEOGRAPH-5B57 (OLetter) × [5.0] WORD JOINER (Format) × [998.0] IDEOGRAPHIC FULL STOP (STerm) × [5.0] WORD JOINER (Format) ÷ [11.0] CJK UNIFIED IDEOGRAPH-5B83 (OLetter) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x21, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x21, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0x20, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] EXCLAMATION MARK (STerm) × [5.0] WORD JOINER (Format) × [9.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [10.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER A (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xd, 0xe2, 0x81, 0xa0, 0xa, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xd}, {0xe2, 0x81, 0xa0, 0xa}, {0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER A (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] (CR) ÷ [4.0] WORD JOINER (Format) × [998.0] (LF) ÷ [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xd, 0xe2, 0x81, 0xa0, 0xa, 0x20, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xd}, {0xe2, 0x81, 0xa0, 0xa}, {0x20, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER A (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] (CR) ÷ [4.0] WORD JOINER (Format) × [998.0] (LF) ÷ [4.0] SPACE (Sp) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xd, 0xe2, 0x81, 0xa0, 0xa, 0x61, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xd}, {0xe2, 0x81, 0xa0, 0xa}, {0x61, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN SMALL LETTER A (Lower) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] (CR) ÷ [4.0] WORD JOINER (Format) × [998.0] (LF) ÷ [4.0] LATIN SMALL LETTER A (Lower) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x81, 0xa0, 0x41, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xd, 0xe2, 0x81, 0xa0, 0xa, 0x41, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x81, 0xa0, 0x41, 0xe2, 0x81, 0xa0, 0x2e, 0xe2, 0x81, 0xa0, 0xd}, {0xe2, 0x81, 0xa0, 0xa}, {0x41, 0xe2, 0x81, 0xa0, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] WORD JOINER (Format) × [998.0] LATIN CAPITAL LETTER A (Upper) × [5.0] WORD JOINER (Format) × [998.0] FULL STOP (ATerm) × [5.0] WORD JOINER (Format) × [9.0] (CR) ÷ [4.0] WORD JOINER (Format) × [998.0] (LF) ÷ [4.0] LATIN CAPITAL LETTER A (Upper) × [5.0] WORD JOINER (Format) × [5.0] WORD JOINER (Format) ÷ [0.3]", }, } golang-github-clipperhouse-uax29-2.7.0/testdata/000077500000000000000000000000001515045622700215355ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/testdata/UTF-8-test.txt000066400000000000000000000543751515045622700240740ustar00rootroot00000000000000UTF-8 decoder capability and stress test ---------------------------------------- Markus Kuhn - 2015-08-28 - CC BY 4.0 This test file can help you examine, how your UTF-8 decoder handles various types of correct, malformed, or otherwise interesting UTF-8 sequences. This file is not meant to be a conformance test. It does not prescribe any particular outcome. Therefore, there is no way to "pass" or "fail" this test file, even though the text does suggest a preferable decoder behaviour at some places. Its aim is, instead, to help you think about, and test, the behaviour of your UTF-8 decoder on a systematic collection of unusual inputs. Experience so far suggests that most first-time authors of UTF-8 decoders find at least one serious problem in their decoder using this file. The test lines below cover boundary conditions, malformed UTF-8 sequences, as well as correctly encoded UTF-8 sequences of Unicode code points that should never occur in a correct UTF-8 file. According to ISO 10646-1:2000, sections D.7 and 2.3c, a device receiving UTF-8 shall interpret a "malformed sequence in the same way that it interprets a character that is outside the adopted subset" and "characters that are not within the adopted subset shall be indicated to the user" by a receiving device. One commonly used approach in UTF-8 decoders is to replace any malformed UTF-8 sequence by a replacement character (U+FFFD), which looks a bit like an inverted question mark, or a similar symbol. It might be a good idea to visually distinguish a malformed UTF-8 sequence from a correctly encoded Unicode character that is just not available in the current font but otherwise fully legal, even though ISO 10646-1 doesn't mandate this. In any case, just ignoring malformed sequences or unavailable characters does not conform to ISO 10646, will make debugging more difficult, and can lead to user confusion. Please check, whether a malformed UTF-8 sequence is (1) represented at all, (2) represented by exactly one single replacement character (or equivalent signal), and (3) the following quotation mark after an illegal UTF-8 sequence is correctly displayed, i.e. proper resynchronization takes place immediately after any malformed sequence. This file says "THE END" in the last line, so if you don't see that, your decoder crashed somehow before, which should always be cause for concern. All lines in this file are exactly 79 characters long (plus the line feed). In addition, all lines end with "|", except for the two test lines 2.1.1 and 2.2.1, which contain non-printable ASCII controls U+0000 and U+007F. If you display this file with a fixed-width font, these "|" characters should all line up in column 79 (right margin). This allows you to test quickly, whether your UTF-8 decoder finds the correct number of characters in every line, that is whether each malformed sequences is replaced by a single replacement character. Note that, as an alternative to the notion of malformed sequence used here, it is also a perfectly acceptable (and in some situations even preferable) solution to represent each individual byte of a malformed sequence with a replacement character. If you follow this strategy in your decoder, then please ignore the "|" column. Here come the tests: | | 1 Some correct UTF-8 text | | You should see the Greek word 'kosme': "κόσμε" | | 2 Boundary condition test cases | | 2.1 First possible sequence of a certain length | | 2.1.1 1 byte (U-00000000): "" 2.1.2 2 bytes (U-00000080): "€" | 2.1.3 3 bytes (U-00000800): "ࠀ" | 2.1.4 4 bytes (U-00010000): "𐀀" | 2.1.5 5 bytes (U-00200000): "" | 2.1.6 6 bytes (U-04000000): "" | | 2.2 Last possible sequence of a certain length | | 2.2.1 1 byte (U-0000007F): "" 2.2.2 2 bytes (U-000007FF): "߿" | 2.2.3 3 bytes (U-0000FFFF): "￿" | 2.2.4 4 bytes (U-001FFFFF): "" | 2.2.5 5 bytes (U-03FFFFFF): "" | 2.2.6 6 bytes (U-7FFFFFFF): "" | | 2.3 Other boundary conditions | | 2.3.1 U-0000D7FF = ed 9f bf = "퟿" | 2.3.2 U-0000E000 = ee 80 80 = "" | 2.3.3 U-0000FFFD = ef bf bd = "�" | 2.3.4 U-0010FFFF = f4 8f bf bf = "􏿿" | 2.3.5 U-00110000 = f4 90 80 80 = "" | | 3 Malformed sequences | | 3.1 Unexpected continuation bytes | | Each unexpected continuation byte should be separately signalled as a | malformed sequence of its own. | | 3.1.1 First continuation byte 0x80: "" | 3.1.2 Last continuation byte 0xbf: "" | | 3.1.3 2 continuation bytes: "" | 3.1.4 3 continuation bytes: "" | 3.1.5 4 continuation bytes: "" | 3.1.6 5 continuation bytes: "" | 3.1.7 6 continuation bytes: "" | 3.1.8 7 continuation bytes: "" | | 3.1.9 Sequence of all 64 possible continuation bytes (0x80-0xbf): | | " | | | " | | 3.2 Lonely start characters | | 3.2.1 All 32 first bytes of 2-byte sequences (0xc0-0xdf), | each followed by a space character: | | " | " | | 3.2.2 All 16 first bytes of 3-byte sequences (0xe0-0xef), | each followed by a space character: | | " " | | 3.2.3 All 8 first bytes of 4-byte sequences (0xf0-0xf7), | each followed by a space character: | | " " | | 3.2.4 All 4 first bytes of 5-byte sequences (0xf8-0xfb), | each followed by a space character: | | " " | | 3.2.5 All 2 first bytes of 6-byte sequences (0xfc-0xfd), | each followed by a space character: | | " " | | 3.3 Sequences with last continuation byte missing | | All bytes of an incomplete sequence should be signalled as a single | malformed sequence, i.e., you should see only a single replacement | character in each of the next 10 tests. (Characters as in section 2) | | 3.3.1 2-byte sequence with last byte missing (U+0000): "" | 3.3.2 3-byte sequence with last byte missing (U+0000): "" | 3.3.3 4-byte sequence with last byte missing (U+0000): "" | 3.3.4 5-byte sequence with last byte missing (U+0000): "" | 3.3.5 6-byte sequence with last byte missing (U+0000): "" | 3.3.6 2-byte sequence with last byte missing (U-000007FF): "" | 3.3.7 3-byte sequence with last byte missing (U-0000FFFF): "" | 3.3.8 4-byte sequence with last byte missing (U-001FFFFF): "" | 3.3.9 5-byte sequence with last byte missing (U-03FFFFFF): "" | 3.3.10 6-byte sequence with last byte missing (U-7FFFFFFF): "" | | 3.4 Concatenation of incomplete sequences | | All the 10 sequences of 3.3 concatenated, you should see 10 malformed | sequences being signalled: | | "" | | 3.5 Impossible bytes | | The following two bytes cannot appear in a correct UTF-8 string | | 3.5.1 fe = "" | 3.5.2 ff = "" | 3.5.3 fe fe ff ff = "" | | 4 Overlong sequences | | The following sequences are not malformed according to the letter of | the Unicode 2.0 standard. However, they are longer then necessary and | a correct UTF-8 encoder is not allowed to produce them. A "safe UTF-8 | decoder" should reject them just like malformed sequences for two | reasons: (1) It helps to debug applications if overlong sequences are | not treated as valid representations of characters, because this helps | to spot problems more quickly. (2) Overlong sequences provide | alternative representations of characters, that could maliciously be | used to bypass filters that check only for ASCII characters. For | instance, a 2-byte encoded line feed (LF) would not be caught by a | line counter that counts only 0x0a bytes, but it would still be | processed as a line feed by an unsafe UTF-8 decoder later in the | pipeline. From a security point of view, ASCII compatibility of UTF-8 | sequences means also, that ASCII characters are *only* allowed to be | represented by ASCII bytes in the range 0x00-0x7f. To ensure this | aspect of ASCII compatibility, use only "safe UTF-8 decoders" that | reject overlong UTF-8 sequences for which a shorter encoding exists. | | 4.1 Examples of an overlong ASCII character | | With a safe UTF-8 decoder, all of the following five overlong | representations of the ASCII character slash ("/") should be rejected | like a malformed UTF-8 sequence, for instance by substituting it with | a replacement character. If you see a slash below, you do not have a | safe UTF-8 decoder! | | 4.1.1 U+002F = c0 af = "" | 4.1.2 U+002F = e0 80 af = "" | 4.1.3 U+002F = f0 80 80 af = "" | 4.1.4 U+002F = f8 80 80 80 af = "" | 4.1.5 U+002F = fc 80 80 80 80 af = "" | | 4.2 Maximum overlong sequences | | Below you see the highest Unicode value that is still resulting in an | overlong sequence if represented with the given number of bytes. This | is a boundary test for safe UTF-8 decoders. All five characters should | be rejected like malformed UTF-8 sequences. | | 4.2.1 U-0000007F = c1 bf = "" | 4.2.2 U-000007FF = e0 9f bf = "" | 4.2.3 U-0000FFFF = f0 8f bf bf = "" | 4.2.4 U-001FFFFF = f8 87 bf bf bf = "" | 4.2.5 U-03FFFFFF = fc 83 bf bf bf bf = "" | | 4.3 Overlong representation of the NUL character | | The following five sequences should also be rejected like malformed | UTF-8 sequences and should not be treated like the ASCII NUL | character. | | 4.3.1 U+0000 = c0 80 = "" | 4.3.2 U+0000 = e0 80 80 = "" | 4.3.3 U+0000 = f0 80 80 80 = "" | 4.3.4 U+0000 = f8 80 80 80 80 = "" | 4.3.5 U+0000 = fc 80 80 80 80 80 = "" | | 5 Illegal code positions | | The following UTF-8 sequences should be rejected like malformed | sequences, because they never represent valid ISO 10646 characters and | a UTF-8 decoder that accepts them might introduce security problems | comparable to overlong UTF-8 sequences. | | 5.1 Single UTF-16 surrogates | | 5.1.1 U+D800 = ed a0 80 = "" | 5.1.2 U+DB7F = ed ad bf = "" | 5.1.3 U+DB80 = ed ae 80 = "" | 5.1.4 U+DBFF = ed af bf = "" | 5.1.5 U+DC00 = ed b0 80 = "" | 5.1.6 U+DF80 = ed be 80 = "" | 5.1.7 U+DFFF = ed bf bf = "" | | 5.2 Paired UTF-16 surrogates | | 5.2.1 U+D800 U+DC00 = ed a0 80 ed b0 80 = "" | 5.2.2 U+D800 U+DFFF = ed a0 80 ed bf bf = "" | 5.2.3 U+DB7F U+DC00 = ed ad bf ed b0 80 = "" | 5.2.4 U+DB7F U+DFFF = ed ad bf ed bf bf = "" | 5.2.5 U+DB80 U+DC00 = ed ae 80 ed b0 80 = "" | 5.2.6 U+DB80 U+DFFF = ed ae 80 ed bf bf = "" | 5.2.7 U+DBFF U+DC00 = ed af bf ed b0 80 = "" | 5.2.8 U+DBFF U+DFFF = ed af bf ed bf bf = "" | | 5.3 Noncharacter code positions | | The following "noncharacters" are "reserved for internal use" by | applications, and according to older versions of the Unicode Standard | "should never be interchanged". Unicode Corrigendum #9 dropped the | latter restriction. Nevertheless, their presence in incoming UTF-8 data | can remain a potential security risk, depending on what use is made of | these codes subsequently. Examples of such internal use: | | - Some file APIs with 16-bit characters may use the integer value -1 | = U+FFFF to signal an end-of-file (EOF) or error condition. | | - In some UTF-16 receivers, code point U+FFFE might trigger a | byte-swap operation (to convert between UTF-16LE and UTF-16BE). | | With such internal use of noncharacters, it may be desirable and safer | to block those code points in UTF-8 decoders, as they should never | occur legitimately in incoming UTF-8 data, and could trigger unsafe | behaviour in subsequent processing. | | Particularly problematic noncharacters in 16-bit applications: | | 5.3.1 U+FFFE = ef bf be = "￾" | 5.3.2 U+FFFF = ef bf bf = "￿" | | Other noncharacters: | | 5.3.3 U+FDD0 .. U+FDEF = "﷐﷑﷒﷓﷔﷕﷖﷗﷘﷙﷚﷛﷜﷝﷞﷟﷠﷡﷢﷣﷤﷥﷦﷧﷨﷩﷪﷫﷬﷭﷮﷯"| | 5.3.4 U+nFFFE U+nFFFF (for n = 1..10) | | "🿾🿿𯿾𯿿𿿾𿿿񏿾񏿿񟿾񟿿񯿾񯿿񿿾񿿿򏿾򏿿 | 򟿾򟿿򯿾򯿿򿿾򿿿󏿾󏿿󟿾󟿿󯿾󯿿󿿾󿿿􏿾􏿿" | | THE END | golang-github-clipperhouse-uax29-2.7.0/testdata/sample.txt000066400000000000000000001042221515045622700235600ustar00rootroot00000000000000Generated with help from Grok: https://grok.com/share/bGVnYWN5LWNvcHk%3D_6b7f7d01-4d33-4677-b81b-709f6a8c2ed6 and Cursor. ## English (Latin Script, mostly ASCII) - New York City New York City, often simply referred to as New York, is the most populous city in the United States. With a population of over 8.8 million people within its city limits and around 20 million in the metropolitan area, it stands as a global hub for finance, culture, media, and entertainment. The city is divided into five boroughs: Manhattan, Brooklyn, Queens, the Bronx, and Staten Island, each offering its unique flavor and attractions. One of the most iconic landmarks in New York is the Statue of Liberty, a gift from France symbolizing freedom and democracy. Located on Liberty Island in New York Harbor, it attracts millions of visitors annually who take ferries to see this colossal neoclassical sculpture up close. Another must-see is the Empire State Building, an Art Deco skyscraper that was once the tallest building in the world. From its observation deck on the 86th floor, one can enjoy panoramic views of the city skyline, especially stunning at sunset. Central Park, spanning 843 acres in the heart of Manhattan, serves as a green oasis amid the urban jungle. It's a popular spot for jogging, picnicking, and boating on the lake. The park also hosts events like concerts and Shakespeare in the Park performances during the summer. Times Square, known as "The Crossroads of the World," is famous for its bright neon lights, Broadway theaters, and the annual New Year's Eve ball drop, drawing crowds from around the globe. Sports play a big role in New York's culture. The New York Yankees, a Major League Baseball team, have won 27 World Series championships, more than any other team. They play at Yankee Stadium in the Bronx. Basketball fans root for the New York Knicks, who call Madison Square Garden home, a venue also used for hockey games by the New York Rangers. Football enthusiasts support the New York Giants and New York Jets, both playing at MetLife Stadium in nearby New Jersey. The city's diverse population contributes to its vibrant food scene. From street vendors selling hot dogs and pretzels to high-end restaurants offering cuisines from every corner of the world, there's something for every palate. Pizza slices, bagels with cream cheese, and cheesecake are quintessential New York treats. The subway system, with its 472 stations, is the lifeline of the city, transporting millions daily despite occasional delays. Education and innovation thrive here too. Institutions like Columbia University and New York University attract students globally. Wall Street in Lower Manhattan is the epicenter of the financial world, housing the New York Stock Exchange. Museums such as the Metropolitan Museum of Art and the Museum of Modern Art showcase priceless collections spanning centuries. New York is a city that never sleeps, with nightlife ranging from rooftop bars in Manhattan to live music venues in Brooklyn. Shopping destinations like Fifth Avenue offer luxury brands, while flea markets provide unique finds. The High Line, an elevated park built on a former rail line, offers a peaceful walk with art installations and gardens. Despite challenges like high living costs and traffic congestion, New York's energy and opportunities draw people from all walks of life. It's a melting pot where cultures blend, ideas flourish, and dreams are pursued relentlessly. Whether you're a tourist snapping photos at the Brooklyn Bridge or a local commuting to work, the city's pulse is infectious. ## French (Latin Script with Diacritics) - Paris Paris, souvent appelée «la Ville Lumière», est la capitale de la France et l'une des villes les plus visitées au monde. Avec une population d'environ 2,1 millions d'habitants intra-muros et plus de 12 millions dans l'agglomération, elle est un centre mondial pour l'art, la mode, la gastronomie et la culture. La ville est divisée en 20 arrondissements, chacun avec son caractère unique. L'un des monuments les plus iconiques est la Tour Eiffel, construite pour l'Exposition Universelle de 1889. Située sur le Champ de Mars, elle offre des vues époustouflantes depuis son sommet, surtout illuminée la nuit. Un autre incontournable est le Musée du Louvre, abritant des chefs-d'œuvre comme la Mona Lisa et la Vénus de Milo, attirant des millions de visiteurs chaque année. Les Champs-Élysées, avenue prestigieuse menant à l'Arc de Triomphe, est bordée de boutiques de luxe, cafés et cinémas. Le quartier de Montmartre, avec la Basilique du Sacré-Cœur, est connu pour ses artistes de rue et son ambiance bohème. La Seine traverse la ville, avec des ponts célèbres comme le Pont Neuf, idéal pour des croisières fluviales. En sports, le Paris Saint-Germain (PSG) domine le football français, jouant au Parc des Princes et comptant des stars internationales. Le rugby a le Stade Français, et le tennis brille avec Roland-Garros, tournoi du Grand Chelem. Le basket avec des équipes en Pro A, et le cyclisme avec le Tour de France finissant sur les Champs-Élysées. La cuisine française est renommée : croissants, baguettes, escargots, fromages et vins. Les marchés comme celui de la Rue Cler offrent des produits frais. Le métro parisien, avec ses 16 lignes et stations art nouveau, est efficace bien que bondé aux heures de pointe. Institutions comme la Sorbonne attirent étudiants du monde entier. Quartiers comme Le Marais mêlent histoire et modernité avec galeries et boutiques. Musées comme Orsay exposent impressionnistes. La vie nocturne à Pigalle ou Oberkampf inclut cabarets comme le Moulin Rouge. Paris affronte des défis comme le coût de la vie et le tourisme massif, mais des initiatives vertes comme Vélib' promeuvent les vélos. Jardins comme les Tuileries offrent repos. L'Opéra Garnier accueille ballets. En somme, Paris incarne l'élégance et le romantisme. ## Arabic (Arabic Script, RTL) - القاهرة القاهرة، عاصمة مصر، هي واحدة من أكبر المدن في العالم العربي والأفريقي. مع سكان يبلغ عددهم حوالي 10 ملايين نسمة داخل المدينة وأكثر من 20 مليون في المنطقة الحضرية، تُعتبر مركزاً ثقافياً وتاريخياً وسياسياً نابضاً. المدينة مقسمة إلى أحياء عديدة، كل منها يحمل طابعاً فريداً. من أبرز المعالم السياحية أهرامات الجيزة، التي تشمل هرم خوفو الكبير، رمزاً للحضارة الفرعونية القديمة. تقع على هضبة الجيزة غرب النيل، وتجذب ملايين الزوار سنوياً لاستكشاف عجائبها. كما يوجد المتحف المصري في ميدان التحرير، الذي يحتوي على كنوز توت عنخ آمون وتماثيل فرعونية. ميدان التحرير هو قلب المدينة، حيث وقعت ثورة 2011، ويحيط به مبانٍ حكومية وفنادق. خان الخليلي، سوق تاريخي، مثالي للتسوق من المجوهرات والتوابل. نهر النيل يعبر المدينة، مع جسور مثل قصر النيل، مناسبة للنزهات المسائية. في الرياضة، النادي الأهلي والزمالك هما الخصمان الأبديان في كرة القدم، يلعبان في استاد القاهرة الدولي. المنتخب المصري حقق كأس أفريقيا عدة مرات. كرة السلة مع أندية مثل الجزيرة، والكرة الطائرة شائعة أيضاً. سباقات الخيل في نادي الجزيرة. المطبخ المصري شهي: كشري، فول مدمس، محشي، وكنافة. أسواق مثل عتبة توفر مكونات طازجة. مترو القاهرة، أول في أفريقيا، ينقل ملايين يومياً رغم الازدحام. مؤسسات مثل جامعة القاهرة تجذب طلاباً عربياً. أحياء مثل الزمالك تمزج الفخامة بالتاريخ. متاحف مثل متحف الفن الإسلامي تعرض تحف. الحياة الليلية في وسط البلد تشمل مقاهي ومطاعم. تواجه القاهرة تحديات مثل الزحام والتلوث، لكن مبادرات مثل متروبوليتان تساعد. حدائق مثل الأزهر توفر راحة. دار الأوبرا تستضيف حفلات. باختصار، القاهرة تجسد التاريخ والحيوية. ## Chinese (Simplified Han Script) - 北京 北京是中国首都,是世界上人口最多的城市之一。市区人口约2150万,都市区超过2500万,是政治、经济和文化中心。城市分为多个区,每个区都有独特特色。 最著名的地标是故宫,又称紫禁城,明清王朝的皇宫,现在是博物馆,展示数千件文物。另一个是天安门广场,世界上最大的广场,举办国庆庆典。长城在北京郊区,如八达岭段,吸引游客攀登。 颐和园是皇家园林,占地290公顷,适合散步和划船。王府井大街是购物天堂,有小吃如北京烤鸭。胡同是传统巷道,保留老北京风貌,骑自行车游览不错。 体育方面,北京国安是中超足球队,主场工人体育场。北京首钢篮球队在CBA。奥运会2008在北京举办,水立方和鸟巢是标志。乒乓球是中国国球,北京有许多俱乐部。 中国菜丰富:饺子、宫保鸡丁、麻婆豆腐。小吃街如南锣鼓巷提供街头美食。地铁系统有20多条线,高效但高峰期拥挤。 机构如清华大学吸引全球学生。CBD是商业区,高楼林立。博物馆如首都博物馆展出历史。夜生活在三里屯,包括酒吧和餐厅。 北京面对雾霾和交通问题,但地铁扩展帮助。公园如北海公园提供休闲。国家大剧院举办演出。总之,北京体现传统与现代融合。 ## Japanese (Hiragana, Katakana, Kanji) - 東京 東京は日本の首都で、世界で最も人口の多い都市の一つです。市区人口約1400万人、都市圏で3700万人以上で、政治、経済、文化の中心です。23の特別区に分かれ、それぞれ独自の魅力があります。 最も有名なランドマークは東京タワー、テレビ塔で夜景が美しい。もう一つは浅草寺、東京の古い寺院で、雷門が象徴的。渋谷のスクランブル交差点は世界一の歩行者数で知られます。 皇居は天皇の住居、周囲はジョギングコース。秋葉原はアニメと電子機器の聖地。六本木は現代アートと高層ビルで、森美術館があります。 スポーツでは、読売ジャイアンツがプロ野球の人気チーム、東京ドームでプレー。サッカーのFC東京と浦和レッズのライバル。相撲は両国国技館で、オリンピック2020の会場も残ります。 日本食は寿司、天ぷら、ラーメン。築地市場跡の豊洲市場で新鮮魚。地下鉄は13線、効率的だがラッシュ時混雑。 機関如東京大学が学生を集め。新宿はビジネス区。博物館如国立博物館展示歴史。夜遊びは銀座のバー。 東京は地震と高物価の課題だが、地震対策進む。公園如上野公園で桜見。国立劇場で公演。まとめ、東京は伝統と革新の融合。 ## Korean (Hangul Script) - 서울 서울은 한국의 수도로, 세계에서 가장 인구가 많은 도시 중 하나입니다. 도시 인구 약 1000만 명, 수도권 2500만 명 이상으로, 정치, 경제, 문화 중심입니다. 25개의 구로 나뉘어 각자 독특한 매력을 가집니다. 가장 유명한 랜드마크는 경복궁, 조선 왕조의 궁전으로 역사적 가치가 높습니다. 또 하나는 남산타워, 서울의 전망을 즐길 수 있는 곳입니다. 명동은 쇼핑과 거리 음식으로 유명합니다. 한강은 도시를 가로지르며, 자전거 도로와 공원이 많아 산책에 좋습니다. 인사동은 전통 시장으로, 공예품과 차를 팔아요. 홍대는 거리 공연과 젊은 문화의 중심입니다. 스포츠에서 FC 서울이 K리그 축구 팀, 잠실 경기장에서 플레이합니다. 야구는 두산 베어스와 LG 트윈스 라이벌. 농구 KBL 팀들, 올림픽 1988 유적도 있습니다. 한국 음식은 비빔밥, 김치찌개, 불고기. 홍대나 이태원에서 글로벌 요리. 지하철 9호선 이상, 효율적이지만 출퇴근 혼잡. 기관처럼 서울대학교 학생 유치. 강남은 비즈니스 구역. 박물관 국가박물관 역사 전시. 밤문화 이태원 바. 서울은 교통과 미세먼지 문제 직면하지만, 버스 개혁 도움. 공원 여의도 휴식. 오페라하우스 공연. 요약, 서울 전통과 현대 융합. ## Russian (Cyrillic Script) - Москва Москва, столица России, является одним из крупнейших городов мира. С населением около 12,6 миллионов человек в городе и более 20 миллионов в агломерации, она центр политики, экономики и культуры. Город разделён на 12 административных округов, каждый со своим характером. Одна из самых иконических достопримечательностей — Красная площадь с собором Василия Блаженного и мавзолеем Ленина. Здесь проходят парады и фестивали. Ещё один — Кремль, резиденция президента, с музеями и соборами. Арбат — пешеходная улица с уличными артистами и сувенирами. Парк Горького, 120 гектаров, идеален для катания на коньках зимой и велосипедов летом. Метро Москвы известно станциями как дворцами, с мозаиками и люстрами. В спорте ЦСКА и Спартак — вечные соперники в футболе, играют на стадионах вроде Лужников, где был ЧМ-2018. Хоккей с Динамо, баскетбол с ЦСКА. Теннис в Олимпийском. Русская кухня: блины, борщ, пельмени, икра. Рынки как Даниловский предлагают свежие продукты. Метро с 15 линиями перевозит миллионы, эффективно несмотря на пробки. Институты вроде МГУ привлекают студентов. Тверская — коммерческая улица. Музеи вроде Третьяковской галереи показывают искусство. Ночная жизнь в клубах на Красном Октябре. Москва сталкивается с пробками и зимним холодом, но электробусы помогают. Парки вроде ВДНХ для отдыха. Большой театр принимает балеты. В итоге, Москва воплощает историю и динамику. ## Hindi (Devanagari Script) - मुंबई मुंबई, भारत की आर्थिक राजधानी, दुनिया के सबसे बड़े शहरों में से एक है। शहर की आबादी लगभग 1.2 करोड़ है और महानगरीय क्षेत्र में 2 करोड़ से अधिक, यह वित्त, फिल्म और संस्कृति का केंद्र है। शहर कई हिस्सों में बंटा है, हर एक का अपना आकर्षण है। सबसे प्रसिद्ध स्थल गेटवे ऑफ इंडिया है, ब्रिटिश काल का स्मारक, समुद्र के किनारे स्थित। एक और है छत्रपति शिवाजी टर्मिनस, यूनेस्को स्थल, विक्टोरियन गोथिक शैली में। मरीन ड्राइव रानी का हार जैसा दिखता है, शाम की सैर के लिए आदर्श। जुहू बीच समुद्र तट है, जहां लोग पिकनिक मनाते हैं। बॉलीवुड फिल्म सिटी में शूटिंग होती है। कोलाबा बाजार खरीदारी के लिए, गहने और कपड़े। खेल में मुंबई इंडियंस आईपीएल क्रिकेट टीम, वानखेड़े स्टेडियम में खेलती है, विश्व कप 2011 जीता। फुटबॉल मुंबई सिटी एफसी, हॉकी भी लोकप्रिय। भारतीय व्यंजन: वड़ा पाव, पाव भाजी, बिरयानी। बाजार जैसे क्रॉफर्ड ताजा सामग्री। मेट्रो और लोकल ट्रेन लाखों को ले जाती, हालांकि भीड़भाड़। संस्थान जैसे आईआईटी छात्रों को आकर्षित। बांद्रा लग्जरी क्षेत्र। संग्रहालय जैसे प्रिंस ऑफ वेल्स प्रदर्शनी। नाइटलाइफ़ जुहू बार में। मुंबई ट्रैफिक और मानसून की चुनौतियों का सामना, लेकिन मोनोरेल मदद। पार्क जैसे हैंगिंग गार्डन आराम। ओपेरा हाउस शो। संक्षेप में, मुंबई इतिहास और ऊर्जा का मिश्रण। ## Thai (Thai Script) - กรุงเทพมหานคร กรุงเทพมหานคร หรือที่เรียกสั้น ๆ ว่า กรุงเทพฯ เป็นเมืองหลวงของประเทศไทย และเป็นหนึ่งในเมืองที่มีชีวิตชีวาที่สุดในเอเชียตะวันออกเฉียงใต้ ด้วยประชากรประมาณ 8 ล้านคนในตัวเมือง และมากกว่า 14 ล้านคนในเขตปริมณฑล กรุงเทพฯ เป็นศูนย์กลางของการเมือง เศรษฐกิจ และวัฒนธรรม เมืองนี้แบ่งออกเป็น 50 เขต โดยแต่ละเขตมีเอกลักษณ์เฉพาะตัว สถานที่สำคัญที่โดดเด่นที่สุดคือวัดพระแก้ว ซึ่งตั้งอยู่ในพระบรมมหาราชวัง เป็นที่ประดิษฐานของพระแก้วมรกต อันเป็นสัญลักษณ์ทางศาสนาของชาติ วัดโพธิ์ ซึ่งอยู่ใกล้เคียง เป็นที่รู้จักในฐานะวัดที่มีพระพุทธไสยาสน์ขนาดใหญ่ และเป็นศูนย์กลางการนวดแผนไทย ตลาดน้ำดำเนินสะดวกเป็นสถานที่ท่องเที่ยวยอดนิยม ที่นักท่องเที่ยวสามารถนั่งเรือชมวิถีชีวิตริมน้ำ ถนนข้าวสารเป็นจุดหมายสำหรับนักท่องเที่ยวที่ต้องการสัมผัสบรรยากาศยามค่ำคืนและอาหารข้างทาง แม่น้ำเจ้าพระยาไหลผ่านเมือง มีสะพานพระราม 8 ที่สวยงาม และเหมาะสำหรับการล่องเรือชมวิว สวนลุมพินีเป็นสวนสาธารณะขนาด 57.6 เฮกตาร์ เหมาะสำหรับการวิ่งหรือพักผ่อน ในด้านกีฬา เมืองทองยูไนเต็ดเป็นทีมฟุตบอลชั้นนำในไทยลีก เล่นที่สนามเอสซีจี สเตเดี้ยม มวยไทยเป็นกีฬาแบบดั้งเดิมที่ได้รับความนิยม สนามมวยลุมพินีและราชดำเนินเป็นสถานที่จัดแข่งขันสำคัญ วอลเลย์บอลและตะกร้อก็มีแฟนคลับจำนวนมาก อาหารไทยมีชื่อเสียงระดับโลก: ต้มยำกุ้ง ผัดไทย ส้มตำ และข้าวเหนียวมะม่วง ตลาดนัดจตุจักรมีอาหารและสินค้าหลากหลาย รถไฟฟ้าบีทีเอสและเอ็มอาร์ทีขนส่งผู้คนนับล้าน แม้จะแออัดในชั่วโมงเร่งด่วน สถาบันเช่นจุฬาลงกรณ์มหาวิทยาลัยดึงดูดนักศึกษา สยามเป็นย่านช้อปปิ้งที่มีห้างสรรพสินค้าชั้นนำ พิพิธภัณฑ์สถานแห่งชาติแสดงประวัติศาสตร์ ไนต์ไลฟ์ในสุขุมวิทมีบาร์และคลับ กรุงเทพฯ เผชิญปัญหารถติดและน้ำท่วม แต่รถไฟฟ้าสายใหม่ช่วยได้ สวนเบญจกิติให้พื้นที่พักผ่อน โรงละครแห่งชาติมีการแสดง กรุงเทพฯ เป็นเมืองที่ผสมผสานวัฒนธรรมเก่าและใหม่ ## Bengali (Bengali Script) - কলকাতা কলকাতা, পশ্চিমবঙ্গের রাজধানী, ভারতের অন্যতম প্রধান শহর। শহরের জনসংখ্যা প্রায় ৪৫ লক্ষ এবং মহানগর এলাকায় দেড় কোটিরও বেশি, এটি সংস্কৃতি, শিল্প ও শিক্ষার কেন্দ্র। শহরটি বিভিন্ন ওয়ার্ডে বিভক্ত, প্রতিটির নিজস্ব বৈশিষ্ট্য রয়েছে। সবচেয়ে বিখ্যাত ল্যান্ডমার্ক হল ভিক্টোরিয়া মেমোরিয়াল, ব্রিটিশ আমলের একটি সাদা মার্বেল স্মৃতিস্তম্ভ, যা যাদুঘর হিসেবে কাজ করে। হাওড়া ব্রিজ, গঙ্গা নদীর উপর নির্মিত, শহরের প্রতীক এবং ভারতের ব্যস্ততম সেতুগুলির একটি। দক্ষিণেশ্বর মন্দির, কালী মাতার উৎসর্গীকৃত, ভক্তদের আকর্ষণ করে। ময়দান হল একটি বিশাল উদ্যান, ৪০০ হেক্টর, ফুটবল এবং ঘুড়ি ওড়ানোর জন্য উপযুক্ত। কুমারটুলি হল মূর্তি তৈরির কেন্দ্র, বিশেষত দুর্গাপূজার জন্য। নিউ মার্কেটে কেনাকাটা, থেকে কাপড় থেকে মশলা। খেলাধুলায়, ইস্ট বেঙ্গল এবং মোহনবাগান ফুটবলের চিরপ্রতিদ্বন্দ্বী, ইডেন গার্ডেনে খেলে, যা ক্রিকেটেরও কেন্দ্র। কলকাতা নাইট রাইডার্স আইপিএল দল। কাবাডি এবং ব্যাডমিন্টনও জনপ্রিয়। বাঙালি খাবার: রসগোল্লা, সন্দেশ, মাছের ঝোল। পার্ক স্ট্রিটে বিশ্বের খাবার। মেট্রো রেল দিনে লক্ষাধিক যাত্রী বহন করে, যদিও ভিড় থাকে। প্রতিষ্ঠান যেমন কলকাতা বিশ্ববিদ্যালয় ছাত্রদের আকর্ষণ করে। সল্টলেক হল ব্যবসায়িক এলাকা। ভারতীয় জাদুঘরে ইতিহাস প্রদর্শন। রাতের জীবন রবীন্দ্রসদনে নাটক। কলকাতা ট্রাফিক এবং বর্ষার সমস্যার মুখোমুখি, তবে ট্রাম সাহায্য করে। পার্ক যেমন ইকো পার্ক বিশ্রামের জন্য। বিজ্ঞান নগরী প্রদর্শনী। সংক্ষেপে, কলকাতা ইতিহাস ও জীবনীশক্তির মিশ্রণ। ## Hebrew (Hebrew Script, RTL) - ירושלים ירושלים, בירת ישראל, היא אחת הערים העתיקות והמשמעותיות בעולם. עם אוכלוסייה של כ-950,000 תושבים בעיר עצמה ויותר מ-1.2 מיליון באזור המטרופוליני, היא מרכז דתי, תרבותי ופוליטי. העיר מחולקת לשכונות רבות, כל אחת עם אופי ייחודי משלה. אחד מציוני הדרך האייקוניים ביותר הוא הכותל המערבי, שריד ממקדש שלמה השני, מקום תפילה קדוש ליהודים. העיר העתיקה, אתר מורשת עולמית של אונסק"ו, כוללת את כנסיית הקבר, הר הבית ומסגד אל-אקצא. מגדל דוד, ליד שער יפו, משמש כמוזיאון להיסטוריה של העיר. שוק מחנה יהודה הוא מרכז תוסס לקניות של תוצרת טרייה, תבלינים ומאכלים מקומיים, והופך בלילה למרכז בילויים עם ברים. גן סאקר הוא פארק גדול המשמש לפיקניקים, ספורט ואירועים ציבוריים. רחוב בן יהודה הוא אזור להולכי רגל עם חנויות ובתי קפה. בספורט, מכבי ירושלים היא קבוצת כדורסל מובילה, המשחקת בארנה של ירושלים. קבוצות כדורגל כמו בית"ר ירושלים משחקות באצטדיון טדי, שמארח גם תחרויות אתלטיקה. טיולים רגליים ורכיבה על אופניים פופולריים בהרי יהודה שמסביב. המטבח הישראלי כולל חומוס, פלאפל, שקשוקה ושווארמה. שווקים כמו שוק הכרמל מציעים מרכיבים טריים. מערכת האוטובוסים והרכבת הקלה משנעות מיליונים, אם כי לעיתים עם עומס בשעות השיא. מוסדות כמו האוניברסיטה העברית מושכים סטודנטים מכל העולם. שכונת רחביה משלבת היסטוריה ואדריכלות מודרנית. מוזיאונים כמו מוזיאון ישראל מציגים את מגילות ים המלח. חיי הלילה במרכז העיר כוללים פאבים ומופעי מוזיקה חיה. ירושלים מתמודדת עם אתגרים כמו מתחים פוליטיים ועומס תיירותי, אך יוזמות כמו פארק המסילה משפרות את המרחב הציבורי. גנים כמו גן הוורדים מציעים מנוחה. תיאטרון ירושלים מארח הצגות. בקיצור, ירושלים היא שילוב של קדושה וחיוניות. ## Greek (Greek Script) - Αθήνα Η Αθήνα, πρωτεύουσα της Ελλάδας, είναι μία από τις παλαιότερες πόλεις στον κόσμο, γνωστή ως λίκνο του δυτικού πολιτισμού. Με πληθυσμό περίπου 3,2 εκατομμύρια κατοίκους στην πόλη και πάνω από 4 εκατομμύρια στη μητροπολιτική περιοχή, αποτελεί κέντρο πολιτικής, οικονομίας και πολιτισμού. Η πόλη χωρίζεται σε διάφορες γειτονιές, καθεμία με τη δική της ταυτότητα. Ένα από τα πιο εμβληματικά αξιοθέατα είναι η Ακρόπολη, με τον Παρθενώνα, έναν αρχαίο ναό αφιερωμένο στη θεά Αθηνά, που προσελκύει εκατομμύρια επισκέπτες. Το Εθνικό Αρχαιολογικό Μουσείο φιλοξενεί ανεκτίμητα ευρήματα από την αρχαιότητα, όπως το άγαλμα του Ποσειδώνα. Η Πλάκα, μια γραφική συνοικία στους πρόποδες της Ακρόπολης, είναι γεμάτη στενά δρομάκια και παραδοσιακές ταβέρνες. Η πλατεία Συντάγματος είναι η καρδιά της πόλης, όπου βρίσκεται το Κοινοβούλιο και πραγματοποιούνται παρελάσεις. Ο Λυκαβηττός, ένας λόφος στο κέντρο, προσφέρει πανοραμική θέα, ιδανική για ηλιοβασιλέματα. Το Μοναστηράκι είναι γνωστό για την αγορά του, με αντίκες και σουβενίρ. Στον αθλητισμό, ο Παναθηναϊκός και ο Ολυμπιακός είναι οι μεγάλοι αντίπαλοι στο ποδόσφαιρο, παίζοντας στο Ολυμπιακό Στάδιο, που φιλοξένησε τους Ολυμπιακούς Αγώνες του 2004. Το μπάσκετ είναι επίσης δημοφιλές με τον Παναθηναϊκό BC. Το τένις και η ιστιοπλοΐα προσελκύουν φαν στην ακτή. Η ελληνική κουζίνα περιλαμβάνει σουβλάκι, μουσακά, τζατζίκι και φέτα. Οι αγορές όπως η Κεντρική Αγορά Βαρβάκειος προσφέρουν φρέσκα προϊόντα. Το μετρό της Αθήνας, με τρεις γραμμές, είναι αποτελεσματικό, αν και πολυσύχναστο τις ώρες αιχμής. Ιδρύματα όπως το Εθνικό και Καποδιστριακό Πανεπιστήμιο προσελκύουν φοιτητές. Η Κηφισιά είναι πολυτελής περιοχή με μπουτίκ. Μουσεία όπως το Μουσείο Μπενάκη παρουσιάζουν τέχνη. Η νυχτερινή ζωή στο Γκάζι περιλαμβάνει κλαμπ και ζωντανή μουσική. Η Αθήνα αντιμετωπίζει προκλήσεις όπως η κίνηση και η οικονομική κρίση, αλλά έργα όπως το Ελληνικό βελτιώνουν την πόλη. Πάρκα όπως ο Εθνικός Κήπος προσφέρουν χαλάρωση. Το Ωδείο Ηρώδου Αττικού φιλοξενεί συναυλίες. Εν ολίγοις, η Αθήνα συνδυάζει ιστορία και ζωντάνια. ## Emojis and Symbols ### Common 😀 🎉 🌟 🚀 💡 🎨 🌈 🍕 🎵 🏆 ### Modifiers Skin tone: 👋 👋🏻 👋🏼 👋🏽 👋🏾 👋🏿 Gender: 🧑 👨 👩 🧑‍⚕️ 👨‍⚕️ 👩‍⚕️ Hair style: 🧑‍🦰 👨‍🦰 👩‍🦰 🧑‍🦱 👨‍🦱 👩‍🦱 ### Sequences and Combinations Profession: 👨‍💻 👩‍💻 👨‍🔬 👩‍🔬 👨‍🏫 👩‍🏫 Activity: 🧑‍🤝‍🧑 👨‍❤️‍👨 👩‍❤️‍👩 🧑‍❤️‍💋‍🧑 ### Flags 🇺🇸 🇬🇧 🇫🇷 🇩🇪 🇯🇵 🇰🇷 🇨🇳 🇮🇳 🇧🇷 🇷🇺 Extended: 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🏴󠁧󠁢󠁳󠁣󠁴󠁿 🏴󠁧󠁢󠁷󠁬󠁳󠁿 ### Special Characters Zero-width: ​ ‍ ‌ ‌ ‌ Combining: à á â ã ä å a̧ ą a̱ a̲ Variation: ♀️ ♂️ ♟️ ♞ ♝ ♜ ♛ ♚ ♙ ♘ ### Mathematical and Technical Symbols ∑ ∏ ∫ ∬ ∭ ∮ ∯ ∰ ∇ ∆ ∂ √ ∞ ⌘ ⌥ ⇧ ⌃ ⎋ ⌫ ⌦ ⇥ ⇤ ⇧ ⇪ ### Currency and Financial Symbols $ € £ ¥ ₹ ₽ ₩ ₪ ₨ ₦ ₱ ₫ ₴ ₸ 💰 💵 💴 💶 💷 💸 💳 🏦 📊 📈 📉 ### Food and Beverages 🍎 🍐 🍊 🍋 🍌 🍉 🍇 🍓 🫐 🍈 🥭 🍑 ☕ 🍵 🧃 🥤 🧋 🍺 🍷 🥂 🍾 🥃 🧉 golang-github-clipperhouse-uax29-2.7.0/testdata/testdata.go000066400000000000000000000006541515045622700237020ustar00rootroot00000000000000package testdata import ( "os" "path/filepath" "runtime" ) func InvalidUTF8() ([]byte, error) { return load("UTF-8-test.txt") } func Sample() ([]byte, error) { return load("sample.txt") } func load(filename string) ([]byte, error) { // Get the directory of this source file _, currentFile, _, _ := runtime.Caller(0) dir := filepath.Dir(currentFile) path := filepath.Join(dir, filename) return os.ReadFile(path) } golang-github-clipperhouse-uax29-2.7.0/words/000077500000000000000000000000001515045622700210625ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/words/README.md000066400000000000000000000105201515045622700223370ustar00rootroot00000000000000An implementation of word boundaries from [Unicode text segmentation](https://unicode.org/reports/tr29/#Word_Boundaries) (UAX 29), for Unicode 17. [![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/uax29/v2/words.svg)](https://pkg.go.dev/github.com/clipperhouse/uax29/v2/words) ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg) ## Quick start ``` go get "github.com/clipperhouse/uax29/v2/words" ``` ```go import "github.com/clipperhouse/uax29/v2/words" text := "Hello, 世界. Nice dog! 👍🐶" tokens := words.FromString(text) for tokens.Next() { // Next() returns true until end of data or error fmt.Println(tokens.Value()) // Do something with the current token } ``` _Note: this package returns all tokens, including whitespace and punctuation. It's not strictly "words" in the common sense, it's "split on word boundaries"._ ## Conformance We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-36.html#Tests29). ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg) ## APIs #### If you have a `string` ```go text := "Hello, 世界. Nice dog! 👍🐶" tokens := words.FromString(text) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current word } ``` #### If you have an `io.Reader` `FromReader` embeds a [`bufio.Scanner`](https://pkg.go.dev/bufio#Scanner), so just use those methods. ```go r := getYourReader() // from a file or network maybe tokens := words.FromReader(r) for tokens.Scan() { // Scan() returns true until end of data or error fmt.Println(tokens.Text()) // Do something with the current word } if tokens.Err() != nil { // Check the error log.Fatal(tokens.Err()) } ``` #### If you have a `[]byte` ```go b := []byte("Hello, 世界. Nice dog! 👍🐶") tokens := words.FromBytes(b) for tokens.Next() { // Next() returns true until end of data fmt.Println(tokens.Value()) // Do something with the current word } ``` ### Benchmarks ``` goos: darwin goarch: arm64 pkg: github.com/clipperhouse/uax29/words/comparative cpu: Apple M2 BenchmarkWordsMultilingual/clipperhouse/uax29-8 164760 ns/op 212.20 MB/s 0 B/op 0 allocs/op BenchmarkWordsMultilingual/blevesearch/segment-8 593147 ns/op 58.94 MB/s 40960 B/op 1 allocs/op BenchmarkWordsASCII/clipperhouse/uax29-8 224518 ns/op 282.38 MB/s 0 B/op 0 allocs/op BenchmarkWordsASCII/blevesearch/segment-8 1387461 ns/op 45.69 MB/s 65537 B/op 1 allocs/op ``` ### Invalid inputs Invalid UTF-8 input is considered undefined behavior. We test to ensure that bad inputs will not cause pathological outcomes, such as a panic or infinite loop. Callers should expect “garbage-in, garbage-out”. Your pipeline should probably include a call to [`utf8.Valid()`](https://pkg.go.dev/unicode/utf8#Valid). ### Joiners By default, the UAX #29 standard will split words on hyphens, slashes, @ and other punctuation. You might wish those characters not to break words, by specifying joiners. ```go text := "Hello, 世界. Tell me about your super-cool .com. I'm .01% interested and 3/4 of a mile away. Email me at foo@example.biz. #winning" joiners := &words.Joiners{ Middle: []rune("@-/"), // appearing in the middle of a word Leading: []rune("#."), // appearing at the front of a word } tokens := words.FromString(text) tokens.Joiners(joiners) for tokens.Next() { fmt.Println(tokens.Value()) } ``` ### Limitations This package follows the basic UAX #29 specification. For more idiomatic treatment of words across languages, there is more that can be done, scroll down to the [“Notes:” section of the standard](https://unicode.org/reports/tr29/#Word_Boundary_Rules): > It is not possible to provide a uniform set of rules that resolves all issues across languages or that handles all ambiguous situations within a given language. The goal for the specification presented in this annex is to provide a workable default; tailored implementations can be more sophisticated. golang-github-clipperhouse-uax29-2.7.0/words/bleve_compat.go000066400000000000000000000051021515045622700240470ustar00rootroot00000000000000package words // BleveNumeric determines if a token is Numeric using the Bleve segmenter's. // definition, see: https://github.com/blevesearch/segment/blob/master/segment_words.rl#L199-L207 // This API is experimental. func BleveNumeric(token []byte) bool { var pos, w int var current property var lastExIgnore property // "last excluding ignored categories" var lastLastExIgnore property // "the last one before that" for pos < len(token) { // Remember previous properties to avoid lookups/lookbacks last := current if !last.is(_Ignore) { lastLastExIgnore = lastExIgnore lastExIgnore = last } current, w = lookup(token[pos:]) if pos == 0 { // must start with Numeric|ExtendNumLet if current.is(_Numeric | _ExtendNumLet) { pos += w continue } // not numeric, can move on return false } // https://unicode.org/reports/tr29/#WB8 if last.is(_Numeric) && current.is(_Numeric) { pos += w continue } // https://unicode.org/reports/tr29/#WB11 if current.is(_Numeric) && lastExIgnore.is(_MidNum|_MidNumLetQ) && lastLastExIgnore.is(_Numeric) { pos += w continue } // WB12. Numeric × (MidNum | MidNumLet | Single_Quote) Numeric // https://unicode.org/reports/tr29/#WB12 if current.is(_MidNum|_MidNumLetQ) && lastExIgnore.is(_Numeric) { advance, _ := subsequent(_Numeric, token[pos+w:], true) if advance != notfound { pos += w + advance continue } } // https://unicode.org/reports/tr29/#WB13a if current.is(_ExtendNumLet) && lastExIgnore.is(_Numeric|_ExtendNumLet) { pos += w continue } // https://unicode.org/reports/tr29/#WB13b if current.is(_Numeric) && lastExIgnore.is(_ExtendNumLet) { pos += w continue } // if we get here, none of the above rules apply return false } return true } // BleveIdeographic determines if a token is comprised ideographs, by the // Bleve segmenter's definition. It is the union of Han, Katakana, & Hiragana. // See https://github.com/blevesearch/segment/blob/master/segment_words.rl // ...and search for uses of "Ideo". This API is experimental. func BleveIdeographic(token []byte) bool { var pos int for pos < len(token) { current, w := lookup(token[pos:]) if pos == 0 { // must start with ideo if current.is(_BleveIdeographic) { pos += w continue } // not ideo, can move on return false } // approximates https://unicode.org/reports/tr29/#WB13 if current.is(_BleveIdeographic | _ExtendNumLet | _Ignore) { pos += w continue } // if we get here, none of the above rules apply return false } return true } golang-github-clipperhouse-uax29-2.7.0/words/bleve_compat_test.go000066400000000000000000000113561515045622700251160ustar00rootroot00000000000000// Copyright (c) 2014 Couchbase, Inc. // Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file // except in compliance with the License. You may obtain a copy of the License at // http://www.apache.org/licenses/LICENSE-2.0 // Unless required by applicable law or agreed to in writing, software distributed under the // License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, // either express or implied. See the License for the specific language governing permissions // and limitations under the License. // From https://github.com/blevesearch/segment/blob/master/segment_words_test.go package words_test import ( "bytes" "testing" "github.com/clipperhouse/uax29/v2/internal/iterators/filter" "github.com/clipperhouse/uax29/v2/words" ) var letter filter.Func = func(token []byte) bool { return filter.AlphaNumeric(token) && !words.BleveNumeric(token) } var number filter.Func = words.BleveNumeric var ideo filter.Func = words.BleveIdeographic var none filter.Func = func(token []byte) bool { return !filter.AlphaNumeric(token) && !words.BleveNumeric(token) && !words.BleveIdeographic(token) } func TestAdhocSegmentsWithType(t *testing.T) { t.Parallel() tests := []struct { input []byte output [][]byte outputTypes []filter.Func }{ { input: []byte("Now is the.\n End."), output: [][]byte{ []byte("Now"), // Known difference that bleve segment splits whitespace individually, where // this package concatenates spaces into a single token. This difference // is presumed to be irrelevant. // []byte(" "), []byte(" "), []byte("is"), []byte(" "), []byte("the"), []byte("."), []byte("\n"), []byte(" "), []byte("End"), []byte("."), }, outputTypes: []filter.Func{ letter, none, letter, none, letter, none, none, none, letter, none, }, }, { input: []byte("3.5"), output: [][]byte{ []byte("3.5"), }, outputTypes: []filter.Func{ number, }, }, { input: []byte("age 25"), output: [][]byte{ []byte("age"), []byte(" "), []byte("25"), }, outputTypes: []filter.Func{ letter, none, number, }, }, { input: []byte("cat3.5"), output: [][]byte{ []byte("cat3.5"), }, outputTypes: []filter.Func{ letter, }, }, { input: []byte("c"), output: [][]byte{ []byte("c"), }, outputTypes: []filter.Func{ letter, }, }, { input: []byte("こんにちは世界"), output: [][]byte{ []byte("こ"), []byte("ん"), []byte("に"), []byte("ち"), []byte("は"), []byte("世"), []byte("界"), }, outputTypes: []filter.Func{ ideo, ideo, ideo, ideo, ideo, ideo, ideo, }, }, { input: []byte("你好世界"), output: [][]byte{ []byte("你"), []byte("好"), []byte("世"), []byte("界"), }, outputTypes: []filter.Func{ ideo, ideo, ideo, ideo, }, }, { input: []byte("サッカ"), output: [][]byte{ []byte("サッカ"), }, outputTypes: []filter.Func{ ideo, }, }, // test for wb7b/wb7c { input: []byte(`א"א`), output: [][]byte{ []byte(`א"א`), }, outputTypes: []filter.Func{ letter, }, }, } for _, test := range tests { tokens := words.FromBytes(test.input) i := 0 for tokens.Next() { got := tokens.Value() expected := test.output[i] if !bytes.Equal(expected, got) { t.Fatalf("expected %q, got %q", expected, got) } i++ } if i != len(test.output) { t.Fatalf("missed a token in %q", test.input) } for i, f := range test.outputTypes { expected := test.output[i] if !f(expected) { t.Logf("input: %q, expected: %q\n", test.input, expected) t.Logf("Letter: %t\n", letter(expected)) t.Logf("Ideo: %t\n", ideo(expected)) t.Logf("Number: %t\n", number(expected)) t.Logf("None: %t\n", none(expected)) t.Fatal("nope") } } } for _, test := range tests { tokens := words.FromReader(bytes.NewReader(test.input)) i := 0 for tokens.Scan() { got := tokens.Bytes() expected := test.output[i] if !bytes.Equal(expected, got) { t.Fatalf("expected %q, got %q", expected, got) } i++ } if i != len(test.output) { t.Fatalf("missed a token in %q", test.input) } if err := tokens.Err(); err != nil { t.Fatal(err) } for i, f := range test.outputTypes { output := test.output[i] if !f(output) { t.Logf("input: %q, expected: %q\n", test.input, output) t.Logf("Letter: %t\n", letter(output)) t.Logf("Ideo: %t\n", ideo(output)) t.Logf("Number: %t\n", number(output)) t.Logf("None: %t\n", none(output)) t.Fatal("nope") } } } } golang-github-clipperhouse-uax29-2.7.0/words/bytes_test.go000066400000000000000000000075421515045622700236060ustar00rootroot00000000000000package words_test import ( "bytes" "reflect" "testing" "time" "unicode/utf8" "github.com/clipperhouse/uax29/v2/testdata" "github.com/clipperhouse/uax29/v2/words" ) func TestBytesUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { test := test var all [][]byte tokens := words.FromBytes(test.input) for tokens.Next() { all = append(all, tokens.Value()) } if !reflect.DeepEqual(all, test.expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, all, test.comment) } else { passed++ } } if len(unicodeTests) != passed+failed { t.Errorf("Incomplete %d tests: passed %d, failed %d", len(unicodeTests), passed, failed) } } func TestBytesRoundtrip(t *testing.T) { t.Parallel() const runs = 100 tokens := words.FromBytes(nil) for i := 0; i < runs; i++ { input := getRandomBytes() tokens.SetText(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatal("input bytes are not the same as output bytes") } } } func iterToSet(tokens *words.Iterator[[]byte]) map[string]struct{} { founds := make(map[string]struct{}) for tokens.Next() { founds[string(tokens.Value())] = struct{}{} } return founds } func TestBytesJoiners(t *testing.T) { tokens1 := words.FromBytes(joinersInput) founds1 := iterToSet(tokens1) tokens2 := words.FromBytes(joinersInput) tokens2.Joiners(joiners) founds2 := iterToSet(tokens2) for _, test := range joinersTests { _, found1 := founds1[test.input] if found1 != test.found1 { t.Fatalf("For %q, expected %t for found in non-config iterator, but got %t", test.input, test.found1, found1) } _, found2 := founds2[test.input] if found2 != test.found2 { t.Fatalf("For %q, expected %t for found in iterator with joiners, but got %t", test.input, test.found2, found2) } } } func TestBytesInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } tokens := words.FromBytes(input) var output []byte for tokens.Next() { output = append(output, tokens.Value()...) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as output bytes") } } func BenchmarkBytes(b *testing.B) { benchBytes(b, nil) } func benchBytes(b *testing.B, joiners *words.Joiners[[]byte]) { file, err := testdata.Sample() if err != nil { b.Error(err) } bytes := len(file) b.SetBytes(int64(bytes)) c := 0 b.ResetTimer() start := time.Now() for i := 0; i < b.N; i++ { tokens := words.FromBytes(file) if joiners != nil { tokens.Joiners(joiners) } for tokens.Next() { _ = tokens.Value() c++ } } elapsed := time.Since(start) n := float64(b.N) tokensPerOp := float64(c) / n nsPerOp := float64(elapsed.Nanoseconds()) / n b.ReportMetric(1e3*tokensPerOp/nsPerOp, "Mtok/s") b.ReportMetric(tokensPerOp, "tok/op") b.ReportMetric(float64(bytes)/tokensPerOp, "B/tok") } func BenchmarkBytesJoiners(b *testing.B) { var joiners = &words.Joiners[[]byte]{ Middle: []rune("@-/"), Leading: []rune("#."), } benchBytes(b, joiners) } func BenchmarkBytesUnicodeTests(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := words.FromBytes(file) c := 0 for tokens.Next() { _ = tokens.Value() c++ } b.ReportMetric(float64(c), "tokens") } } golang-github-clipperhouse-uax29-2.7.0/words/comparative/000077500000000000000000000000001515045622700233745ustar00rootroot00000000000000golang-github-clipperhouse-uax29-2.7.0/words/comparative/comparative_test.go000066400000000000000000000052461515045622700273030ustar00rootroot00000000000000package comparative import ( "strings" "testing" "github.com/blevesearch/segment" "github.com/clipperhouse/uax29/v2/testdata" "github.com/clipperhouse/uax29/v2/words" ) // asciiProse is typical English prose, ASCII only, for benchmarking the ASCII fast path var asciiProse = strings.Repeat(`The quick brown fox jumps over the lazy dog. This is a sample of typical English prose that contains common words and punctuation. Software engineers often work with text processing and need efficient algorithms to handle large amounts of data. The performance of text segmentation can be critical in search engines and natural language processing applications. When dealing with ASCII text the optimizer can take shortcuts that would not be safe with arbitrary Unicode input. Numbers like 12345 and mixed tokens like abc123 should also be handled efficiently. Short words are common in English text and spaces separate them cleanly. `, 100) func BenchmarkWordsMultilingual(b *testing.B) { data, err := testdata.Sample() if err != nil { b.Fatal(err) } text := string(data) b.Run("clipperhouse/uax29", func(b *testing.B) { b.SetBytes(int64(len(text))) for i := 0; i < b.N; i++ { count := 0 tokens := words.FromString(text) for tokens.Next() { count++ } } }) b.Run("blevesearch/segment", func(b *testing.B) { b.SetBytes(int64(len(text))) for i := 0; i < b.N; i++ { count := 0 segmenter := segment.NewWordSegmenterDirect([]byte(text)) for segmenter.Segment() { count++ } } }) } func BenchmarkWordsASCII(b *testing.B) { b.Run("clipperhouse/uax29", func(b *testing.B) { b.SetBytes(int64(len(asciiProse))) for i := 0; i < b.N; i++ { count := 0 tokens := words.FromString(asciiProse) for tokens.Next() { count++ } } }) b.Run("blevesearch/segment", func(b *testing.B) { b.SetBytes(int64(len(asciiProse))) for i := 0; i < b.N; i++ { count := 0 segmenter := segment.NewWordSegmenterDirect([]byte(asciiProse)) for segmenter.Segment() { count++ } } }) } // Test that both implementations produce the same number of words func TestWordCountConsistency(t *testing.T) { data, err := testdata.Sample() if err != nil { t.Fatal(err) } text := string(data) // Count with UAX29 uax29Count := 0 tokens := words.FromString(text) for tokens.Next() { uax29Count++ } // Count with blevesearch/segment bleveCount := 0 segmenter := segment.NewWordSegmenterDirect([]byte(text)) for segmenter.Segment() { bleveCount++ } t.Logf("UAX29: %d words, blevesearch: %d words", uax29Count, bleveCount) if uax29Count != bleveCount { t.Logf("Note: Different word counts likely due to different boundary rule implementations") } } golang-github-clipperhouse-uax29-2.7.0/words/comparative/go.mod000066400000000000000000000003211515045622700244760ustar00rootroot00000000000000module github.com/clipperhouse/uax29/words/comparative go 1.18 replace github.com/clipperhouse/uax29/v2 => ../../ require ( github.com/blevesearch/segment v0.9.1 github.com/clipperhouse/uax29/v2 v2.6.0 ) golang-github-clipperhouse-uax29-2.7.0/words/comparative/go.sum000066400000000000000000000002631515045622700245300ustar00rootroot00000000000000github.com/blevesearch/segment v0.9.1 h1:+dThDy+Lvgj5JMxhmOVlgFfkUtZV2kw49xax4+jTfSU= github.com/blevesearch/segment v0.9.1/go.mod h1:zN21iLm7+GnBHWTao9I+Au/7MBiL8pPFtJBJTsk6kQw= golang-github-clipperhouse-uax29-2.7.0/words/fuzz_test.go000066400000000000000000000063121515045622700234500ustar00rootroot00000000000000package words_test import ( "bytes" mathrand "math/rand" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/testdata" "github.com/clipperhouse/uax29/v2/words" ) // FuzzValidShort fuzzes small, valid UTF8 strings. I suspect more, shorter // strings in the corpus lead to more mutation and coverage. True? func FuzzValidShort(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } // unicode test suite for _, test := range unicodeTests { f.Add(test.input) } // multi-lingual text, as small-ish lines file, err := testdata.Sample() if err != nil { f.Error(err) } lines := bytes.Split(file, []byte("\n")) for _, line := range lines { f.Add(line) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := words.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzValidLong fuzzes longer, valid UTF8 strings. func FuzzValidLong(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } // add multi-lingual text, as decent (paragraph-sized) size chunks file, err := testdata.Sample() if err != nil { f.Error(err) } chunks := bytes.Split(file, []byte("\n\n\n")) for _, chunk := range chunks { f.Add(chunk) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := words.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } // FuzzInvalid fuzzes invalid UTF8 strings. func FuzzInvalid(f *testing.F) { if testing.Short() { f.Skip("skipping fuzz test in short mode") } random := getRandomBytes() const max = 100 const min = 1 pos := 0 for { // random smaller strings ln := mathrand.Intn(max-min) + min if pos+ln > len(random) { break } f.Add(random[pos : pos+ln]) pos += ln } // known invalid utf-8 badUTF8, err := testdata.InvalidUTF8() if err != nil { f.Error(err) } lines := bytes.Split(badUTF8, []byte("\n")) for _, line := range lines { f.Add(line) } f.Fuzz(func(t *testing.T, original []byte) { var all [][]byte valid1 := utf8.Valid(original) tokens := words.FromBytes(original) for tokens.Next() { all = append(all, tokens.Value()) } roundtrip := make([]byte, 0, len(original)) for _, s := range all { roundtrip = append(roundtrip, s...) } if !bytes.Equal(roundtrip, original) { t.Error("bytes did not roundtrip") } valid2 := utf8.Valid(roundtrip) if valid1 != valid2 { t.Error("utf8 validity of original did not match roundtrip") } }) } golang-github-clipperhouse-uax29-2.7.0/words/iterator.go000066400000000000000000000061421515045622700232450ustar00rootroot00000000000000package words // Iterator is a generic iterator for words in strings or byte slices, // with an ASCII hot path optimization. type Iterator[T ~string | ~[]byte] struct { split func(T, bool) (int, T, error) data T pos int start int } var ( splitFuncString = splitFunc[string] splitFuncBytes = splitFunc[[]byte] ) // FromString returns an iterator for the words in the input string. // Iterate while Next() is true, and access the word via Value(). func FromString(s string) *Iterator[string] { return &Iterator[string]{ split: splitFuncString, data: s, } } // FromBytes returns an iterator for the words in the input bytes. // Iterate while Next() is true, and access the word via Value(). func FromBytes(b []byte) *Iterator[[]byte] { return &Iterator[[]byte]{ split: splitFuncBytes, data: b, } } // isASCIIAlphanumeric returns true if b is in [a-zA-Z0-9] func isASCIIAlphanumeric(b byte) bool { return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9') } // Next advances the iterator to the next word. // Returns false when there are no more words. func (iter *Iterator[T]) Next() bool { if iter.pos >= len(iter.data) { return false } iter.start = iter.pos // ASCII hot path: consume contiguous ASCII alphanumerics // followed by ASCII space (or end of data) b := iter.data[iter.pos] if isASCIIAlphanumeric(b) { // Consume all contiguous ASCII alphanumerics end := iter.pos + 1 for end < len(iter.data) && isASCIIAlphanumeric(iter.data[end]) { end++ } // Check if followed by ASCII space or end of data if end >= len(iter.data) || iter.data[end] == ' ' { iter.pos = end return true } // Otherwise fall through to splitFunc } // Fall back to full word parsing remaining := iter.data[iter.pos:] advance, _, err := iter.split(remaining, true) if err != nil { panic(err) } if advance <= 0 { panic("splitFunc returned a zero or negative advance") } iter.pos += advance if iter.pos > len(iter.data) { panic("splitFunc advanced beyond end of data") } return true } // Value returns the current word. func (iter *Iterator[T]) Value() T { return iter.data[iter.start:iter.pos] } // Start returns the byte position of the current word in the original data. func (iter *Iterator[T]) Start() int { return iter.start } // End returns the byte position after the current word in the original data. func (iter *Iterator[T]) End() int { return iter.pos } // Reset resets the iterator to the beginning of the data. func (iter *Iterator[T]) Reset() { iter.start = 0 iter.pos = 0 } // SetText sets the data for the iterator to operate on, and resets all state. func (iter *Iterator[T]) SetText(data T) { iter.data = data iter.start = 0 iter.pos = 0 } // Split sets the SplitFunc for the Iterator. func (iter *Iterator[T]) Split(split func(T, bool) (int, T, error)) { iter.split = split } // First returns the first word without advancing the iterator. func (iter *Iterator[T]) First() T { if len(iter.data) == 0 { return iter.data } // Use a copy to leverage Next()'s ASCII optimization cp := *iter cp.pos = 0 cp.start = 0 cp.Next() return cp.Value() } golang-github-clipperhouse-uax29-2.7.0/words/joiners.go000066400000000000000000000025441515045622700230670ustar00rootroot00000000000000package words // Joiners sets runes that should be treated like word characters, where // otherwise words will be split. See the [Joiners] type. func (iter *Iterator[T]) Joiners(j *Joiners[T]) { iter.Split(j.splitFunc) } // Joiners allows specification of characters (runes) which will join words (tokens) // rather than breaking them. For example, "@" breaks words by default, // but you might wish to join words into email addresses. type Joiners[T ~string | ~[]byte] struct { // Middle specifies which characters (runes) should // join words (tokens) where they would otherwise be split, // in the middle of a word. // // For example, specifying "-" will join hypenated-words. // Specifying "@" will preserve email addresses. // // Note that . (as in "example.com") and ' (as in "it's") are already mid-joiners, // specifying them will be redundant and hurt performance. Middle []rune // Leading specifies which characters (runes) should // join words (tokens) where they would otherwise be split, // at the beginning of a word. // // For example, specifying "#" will join #hashtags. // Specifying "." will preserve leading decimals like .01. Leading []rune } func runesContain(runes []rune, rune rune) bool { // Did some bechmarking, a map isn't faster for small numbers for _, r := range runes { if r == rune { return true } } return false } golang-github-clipperhouse-uax29-2.7.0/words/joiners_test.go000066400000000000000000000050331515045622700241220ustar00rootroot00000000000000package words_test import ( "testing" "github.com/clipperhouse/uax29/v2/words" ) var joinersInput = []byte("Hello, 世界. Tell me about your super-cool .com. I'm .01% interested and 3/4 of a mile away. Email me at foo@example.biz. #winning") var joiners = &words.Joiners[[]byte]{ Middle: []rune("@-/"), Leading: []rune("#."), } type joinersTest struct { input string // word should be found in standard iterator found1 bool // word should be found in iterator with joiners found2 bool } var joinersTests = []joinersTest{ {"Hello", true, true}, {"世", true, true}, {"super", true, false}, {"-", true, false}, {"cool", true, false}, {"super-cool", false, true}, {"com", true, false}, // ".com" should usually be split, but joined with config {".com", false, true}, {"01", true, false}, {".01", false, true}, {"3", true, false}, {"3/4", false, true}, {"foo", true, false}, {"@", true, false}, {"example.biz", true, false}, {"foo@example.biz", false, true}, {"#", true, false}, {"winning", true, false}, {"#winning", false, true}, } func TestGenericIteratorWithJoiners(t *testing.T) { t.Parallel() // Test with []byte and joiners text := []byte("Hello, 世界. Tell me about your super-cool .com. I'm .01% interested and 3/4 of a mile away. Email me at foo@example.biz. #winning") iter := words.FromBytes(text) joiners := &words.Joiners[[]byte]{ Middle: []rune("@-/"), Leading: []rune("#."), } iter.Joiners(joiners) var results []string for iter.Next() { results = append(results, string(iter.Value())) } // Check that some specific joined tokens exist expectedJoined := []string{"super-cool", ".com", ".01", "3/4", "foo@example.biz", "#winning"} for _, expected := range expectedJoined { found := false for _, result := range results { if result == expected { found = true break } } if !found { t.Errorf("Expected joined token %q not found in results", expected) } } // Test with string and joiners textStr := string(text) iterStr := words.FromString(textStr) joinersStr := &words.Joiners[string]{ Middle: []rune("@-/"), Leading: []rune("#."), } iterStr.Joiners(joinersStr) var resultsStr []string for iterStr.Next() { resultsStr = append(resultsStr, iterStr.Value()) } // Check that some specific joined tokens exist for _, expected := range expectedJoined { found := false for _, result := range resultsStr { if result == expected { found = true break } } if !found { t.Errorf("Expected joined token %q not found in string results", expected) } } } golang-github-clipperhouse-uax29-2.7.0/words/reader.go000066400000000000000000000015431515045622700226560ustar00rootroot00000000000000// Package words implements Unicode word boundaries: https://unicode.org/reports/tr29/#Word_Boundaries package words import ( "bufio" "io" ) type Scanner struct { *bufio.Scanner } // FromReader returns a Scanner, to split words per // https://unicode.org/reports/tr29/#Word_Boundaries. // // It embeds a [bufio.Scanner], so you can use its methods. // // Iterate through words by calling Scan() until false, then check Err(). func FromReader(r io.Reader) *Scanner { s := bufio.NewScanner(r) s.Split(SplitFunc) sc := &Scanner{ Scanner: s, } return sc } // Joiners sets runes that should be treated like word characters, where // otherwsie words sill be split. See the [Joiners] type. func (sc *Scanner) Joiners(j *Joiners[[]byte]) { sc.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) { return j.splitFunc(data, atEOF) }) } golang-github-clipperhouse-uax29-2.7.0/words/reader_test.go000066400000000000000000000113201515045622700237070ustar00rootroot00000000000000package words_test import ( "bytes" "crypto/rand" mathrand "math/rand" "reflect" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/testdata" "github.com/clipperhouse/uax29/v2/words" ) func TestScannerUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { var scanned [][]byte scanner := words.FromReader(bytes.NewReader(test.input)) for scanner.Scan() { scanned = append(scanned, scanner.Bytes()) } if err := scanner.Err(); err != nil { t.Fatal(err) } if !reflect.DeepEqual(scanned, test.expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, scanned, test.comment) } else { passed++ } } t.Logf("%d tests: passed %d, failed %d", len(unicodeTests), passed, failed) } func TestScannerRoundtrip(t *testing.T) { t.Parallel() const runs = 100 for i := 0; i < runs; i++ { input := getRandomBytes() r := bytes.NewReader(input) sc := words.FromReader(r) var output []byte for sc.Scan() { output = append(output, sc.Bytes()...) } if err := sc.Err(); err != nil { t.Fatal(err) } if !bytes.Equal(output, input) { t.Fatal("input bytes are not the same as scanned bytes") } } } func scanToSet(tokens *words.Scanner) map[string]struct{} { founds := make(map[string]struct{}) for tokens.Scan() { founds[string(tokens.Bytes())] = struct{}{} } return founds } func TestScannerJoiners(t *testing.T) { r1 := bytes.NewReader(joinersInput) tokens1 := words.FromReader(r1) founds1 := scanToSet(tokens1) r2 := bytes.NewReader(joinersInput) tokens2 := words.FromReader(r2) tokens2.Joiners(joiners) founds2 := scanToSet(tokens2) for _, test := range joinersTests { _, found1 := founds1[test.input] if found1 != test.found1 { t.Fatalf("For %q, expected %t for found in non-config scanner, but got %t", test.input, test.found1, found1) } _, found2 := founds2[test.input] if found2 != test.found2 { t.Fatalf("For %q, expected %t for found in scanner with joiners, but got %t", test.input, test.found2, found2) } } } func TestInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } r := bytes.NewReader(input) tokens := words.FromReader(r) var output []byte for tokens.Scan() { output = append(output, tokens.Bytes()...) } if err := tokens.Err(); err != nil { t.Error(err) } if !bytes.Equal(output, input) { t.Fatalf("input bytes are not the same as scanned bytes") } } func TestNeverZeroAtEOF(t *testing.T) { t.Parallel() // SplitFunc should never return advance = 0 when atEOF. This test is redundant // with the roundtrip test above, but nice to call out this invariant. const runs = 100 atEOF := true for i := 0; i < runs; i++ { input := getRandomBytes() advance, _, _ := words.SplitFunc(input, atEOF) if advance == 0 { t.Errorf("advance should never be zero (atEOF %t)", atEOF) } } } func TestNeverErr(t *testing.T) { t.Parallel() // SplitFunc should never return an error. This test is redundant // with the roundtrip test above, but nice to call out this invariant. const runs = 100 atEOFs := []bool{true, false} for i := 0; i < runs; i++ { for _, atEOF := range atEOFs { input := getRandomBytes() _, _, err := words.SplitFunc(input, atEOF) if err != nil { t.Errorf("SplitFunc should never error (atEOF %t)", atEOF) } } } } func getRandomBytes() []byte { const max = 10000 const min = 1 len := mathrand.Intn(max-min) + min b := make([]byte, len) _, _ = rand.Read(b) return b } func BenchmarkScanner(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } b.ResetTimer() b.SetBytes(int64(len(file))) r := bytes.NewReader(file) for i := 0; i < b.N; i++ { r.Reset(file) sc := words.FromReader(r) c := 0 for sc.Scan() { c++ } if err := sc.Err(); err != nil { b.Error(err) } b.ReportMetric(float64(c), "tokens") } } func BenchmarkUnicodeScanner(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() b.ResetTimer() b.SetBytes(int64(len(file))) r := bytes.NewReader(file) for i := 0; i < b.N; i++ { r.Reset(file) sc := words.FromReader(r) c := 0 for sc.Scan() { c++ } if err := sc.Err(); err != nil { b.Error(err) } b.ReportMetric(float64(c), "tokens") } } golang-github-clipperhouse-uax29-2.7.0/words/seek.go000066400000000000000000000020061515045622700223360ustar00rootroot00000000000000package words const notfound = -1 // subsequent looks ahead in the buffer until it hits a rune in properties, // ignoring runes with the _Ignore property per WB4 func subsequent[T ~string | ~[]byte](properties property, data T, atEOF bool) (advance int, more bool) { i := 0 for i < len(data) { lookup, w := lookup(data[i:]) if w == 0 { if atEOF { // Nothing more to evaluate return notfound, false } // More to evaluate - return notfound to indicate no match found yet return notfound, true } if lookup.is(_Ignore) { i += w continue } if lookup.is(properties) { // Found it return i, false } // If we see a non-ignored character that doesn't match, // the property is definitely not "immediately subsequent" return notfound, false } // If we reach here, we've only seen ignored characters or incomplete runes if atEOF { // Nothing more to evaluate return notfound, false } // Need more - return notfound to indicate no match found yet return notfound, true } golang-github-clipperhouse-uax29-2.7.0/words/seek_test.go000066400000000000000000000154501515045622700234040ustar00rootroot00000000000000package words import ( "testing" ) func TestSubsequent(t *testing.T) { tests := []struct { name string properties property data []byte atEOF bool expectAdvance int expectMore bool description string }{ // Basic found cases { name: "found_immediately", properties: _Numeric, data: []byte("123"), atEOF: true, expectAdvance: 0, expectMore: false, description: "Should find numeric character at start", }, { name: "found_after_regular_chars", properties: _Numeric, data: []byte("1ab"), // Changed from "a1b" - should find '1' immediately atEOF: true, expectAdvance: 0, expectMore: false, description: "Should find numeric character immediately", }, { name: "found_after_ignored_chars", properties: _Numeric, data: []byte("\u200d1"), // ZWJ + '1' atEOF: true, expectAdvance: 3, // ZWJ is 3 bytes expectMore: false, description: "Should skip ignored ZWJ and find numeric", }, { name: "found_hebrew_letter", properties: _HebrewLetter, data: []byte("א"), // Hebrew Aleph atEOF: true, expectAdvance: 0, expectMore: false, description: "Should find Hebrew letter immediately", }, // Basic not found cases { name: "not_found_definitive", properties: _Numeric, data: []byte("abc"), atEOF: true, expectAdvance: notfound, expectMore: false, description: "Should not find numeric in letters, definitive at EOF", }, { name: "not_found_after_non_matching", properties: _Numeric, data: []byte("xyz"), atEOF: false, expectAdvance: notfound, expectMore: false, description: "Should not find numeric after seeing non-matching letter 'x' (immediate lookup)", }, { name: "not_found_immediate_non_match", properties: _Numeric, data: []byte("a123"), // 'a' doesn't match, should return not found immediately atEOF: true, expectAdvance: notfound, expectMore: false, description: "Should return not found immediately when first char doesn't match", }, { name: "not_found_after_ignored_then_non_matching", properties: _Numeric, data: []byte("\u200dabc"), // ZWJ + letters atEOF: true, expectAdvance: notfound, expectMore: false, description: "Should skip ZWJ but not find numeric in letters", }, // Edge cases with empty data { name: "empty_data_at_eof", properties: _Numeric, data: []byte(""), atEOF: true, expectAdvance: notfound, expectMore: false, description: "Empty data at EOF should return not found", }, { name: "empty_data_not_at_eof", properties: _Numeric, data: []byte(""), atEOF: false, expectAdvance: notfound, expectMore: true, description: "Empty data not at EOF should request more data", }, // Cases with only ignored characters { name: "only_ignored_at_eof", properties: _Numeric, data: []byte("\u200d"), // ZWJ only atEOF: true, expectAdvance: notfound, expectMore: false, description: "Only ignored chars at EOF should return not found", }, { name: "only_ignored_not_at_eof", properties: _Numeric, data: []byte("\u200d"), // ZWJ only atEOF: false, expectAdvance: notfound, expectMore: true, description: "Only ignored chars not at EOF should request more data", }, // Incomplete rune cases { name: "incomplete_rune_at_eof", properties: _Numeric, data: []byte{0xE2, 0x80}, // Incomplete ZWJ (needs 3 bytes) atEOF: true, expectAdvance: notfound, expectMore: false, description: "Incomplete rune at EOF should return not found", }, { name: "incomplete_rune_not_at_eof", properties: _Numeric, data: []byte{0xE2, 0x80}, // Incomplete ZWJ atEOF: false, expectAdvance: notfound, expectMore: true, description: "Incomplete rune not at EOF should request more data", }, // Mixed ignored and non-ignored { name: "ignored_then_found", properties: _AHLetter, data: []byte("\u200d\u034f" + "Hello"), // ZWJ + Combining Grapheme Joiner + letters atEOF: true, expectAdvance: 5, // Skip ZWJ (3 bytes) + CGJ (2 bytes) = 5 bytes expectMore: false, description: "Should skip multiple ignored chars and find letter", }, // Multiple properties { name: "find_any_of_multiple_properties", properties: _Numeric | _AHLetter, data: []byte("A123"), // Changed: should find 'A' immediately atEOF: true, expectAdvance: 0, expectMore: false, description: "Should find letter immediately when looking for numeric OR letter", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { advance, more := subsequent(tt.properties, tt.data, tt.atEOF) if advance != tt.expectAdvance { t.Errorf("advance = %v, expected %v\nDescription: %s", advance, tt.expectAdvance, tt.description) } if more != tt.expectMore { t.Errorf("more = %v, expected %v\nDescription: %s", more, tt.expectMore, tt.description) } }) } } // Test the interaction between subsequent and actual word boundary rules func TestSubsequentWordBoundaryIntegration(t *testing.T) { // Test cases that mirror real word boundary scenarios // WB6: AHLetter × (MidLetter | MidNumLetQ) AHLetter // Looking for AHLetter after seeing MidLetter t.Run("wb6_scenario", func(t *testing.T) { // Simulate: we have "word'" and looking ahead for letter after apostrophe data := []byte("test") // Should find 't' immediately advance, more := subsequent(_AHLetter, data, true) if advance != 0 || more != false { t.Errorf("Expected to find AHLetter immediately, got advance=%d, more=%t", advance, more) } }) // WB7b: HebrewLetter × DoubleQuote HebrewLetter // Looking for HebrewLetter after DoubleQuote t.Run("wb7b_scenario", func(t *testing.T) { data := []byte("א") // Hebrew Aleph advance, more := subsequent(_HebrewLetter, data, true) if advance != 0 || more != false { t.Errorf("Expected to find HebrewLetter immediately, got advance=%d, more=%t", advance, more) } }) // WB12: Numeric × (MidNum | MidNumLetQ) Numeric // Looking for Numeric after MidNum t.Run("wb12_scenario", func(t *testing.T) { data := []byte("5") // Should find numeric immediately advance, more := subsequent(_Numeric, data, true) if advance != 0 || more != false { t.Errorf("Expected to find Numeric immediately, got advance=%d, more=%t", advance, more) } }) } golang-github-clipperhouse-uax29-2.7.0/words/splitfunc.go000066400000000000000000000150701515045622700234230ustar00rootroot00000000000000package words import ( "bufio" "unicode/utf8" ) // is determines if lookup intersects propert(ies) func (lookup property) is(properties property) bool { return (lookup & properties) != 0 } const ( _AHLetter = _ALetter | _HebrewLetter _MidNumLetQ = _MidNumLet | _SingleQuote _Ignore = _Extend | _Format | _ZWJ ) // SplitFunc is a bufio.SplitFunc implementation of word segmentation, for use with bufio.Scanner. // // See https://unicode.org/reports/tr29/#Word_Boundaries. var SplitFunc bufio.SplitFunc = splitFunc[[]byte] func decodeRune[T ~string | ~[]byte](data T) (rune, int) { switch v := any(data).(type) { case string: return utf8.DecodeRuneInString(v) case []byte: return utf8.DecodeRune(v) default: // Handle named string/[]byte types. return utf8.DecodeRuneInString(string(data)) } } func splitFunc[T ~string | ~[]byte](data T, atEOF bool) (advance int, token T, err error) { var none Joiners[T] return none.splitFunc(data, atEOF) } func (j *Joiners[T]) splitFunc(data T, atEOF bool) (advance int, token T, err error) { var empty T if len(data) == 0 { return 0, empty, nil } // These vars are stateful across loop iterations var pos int var lastExIgnore property // "last excluding ignored categories" var lastLastExIgnore property // "the last one before that" var regionalIndicatorCount int // Rules are usually of the form Cat1 × Cat2; "current" refers to the first property // to the right of the ×, from which we look back or forward current, w := lookup(data[pos:]) if w == 0 { if !atEOF { // Rune extends past current data, request more return 0, empty, nil } pos = len(data) return pos, data[:pos], nil } if j != nil && j.Leading != nil { r, _ := decodeRune(data[pos:]) if runesContain(j.Leading, r) { // treat leading joiners as if they are letter, // then depend on the existing logic below current |= _AHLetter } } // https://unicode.org/reports/tr29/#WB1 // Start of text always advances pos += w for { eot := pos == len(data) // "end of text" if eot { if !atEOF { // Token extends past current data, request more return 0, empty, nil } // https://unicode.org/reports/tr29/#WB2 break } // Remember previous properties to avoid lookups/lookbacks last := current if !last.is(_Ignore) { lastLastExIgnore = lastExIgnore lastExIgnore = last } current, w = lookup(data[pos:]) if w == 0 { if atEOF { // Just return the bytes, we can't do anything with them pos = len(data) break } // Rune extends past current data, request more return 0, empty, nil } if j != nil && j.Middle != nil { r, _ := decodeRune(data[pos:]) if runesContain(j.Middle, r) { // treat middle joiners as if they are middle letters/numbers, // then depend on the existing logic below current |= _MidNumLet } } // https://unicode.org/reports/tr29/#WB5 // https://unicode.org/reports/tr29/#WB8 // https://unicode.org/reports/tr29/#WB9 // https://unicode.org/reports/tr29/#WB10 if current.is(_Numeric|_AHLetter) && lastExIgnore.is(_Numeric|_AHLetter) { pos += w continue } // https://unicode.org/reports/tr29/#WB3d if (current & last).is(_WSegSpace) { pos += w continue } // https://unicode.org/reports/tr29/#WB3 if current.is(_LF) && last.is(_CR) { pos += w continue } // https://unicode.org/reports/tr29/#WB3a // https://unicode.org/reports/tr29/#WB3b if (last | current).is(_Newline | _CR | _LF) { break } // https://unicode.org/reports/tr29/#WB3c if current.is(_ExtendedPictographic) && last.is(_ZWJ) { pos += w continue } // https://unicode.org/reports/tr29/#WB4 if current.is(_Extend | _Format | _ZWJ) { pos += w continue } // WB4 applies to subsequent rules; there is an implied "ignoring Extend & Format & ZWJ" // https://unicode.org/reports/tr29/#Grapheme_Cluster_and_Format_Rules // The previous/subsequent funcs are shorthand for "seek a property but skip over Extend|Format|ZWJ on the way" // https://unicode.org/reports/tr29/#WB6 if current.is(_MidLetter|_MidNumLetQ) && lastExIgnore.is(_AHLetter) { advance, more := subsequent(_AHLetter, data[pos+w:], atEOF) if more { // Token extends past current data, request more return 0, empty, nil } found := advance != notfound if found { pos += w + advance continue } } // https://unicode.org/reports/tr29/#WB7 if current.is(_AHLetter) && lastExIgnore.is(_MidLetter|_MidNumLetQ) && lastLastExIgnore.is(_AHLetter) { pos += w continue } // https://unicode.org/reports/tr29/#WB7a if current.is(_SingleQuote) && lastExIgnore.is(_HebrewLetter) { pos += w continue } // https://unicode.org/reports/tr29/#WB7b if current.is(_DoubleQuote) && lastExIgnore.is(_HebrewLetter) { advance, more := subsequent(_HebrewLetter, data[pos+w:], atEOF) if more { // Token extends past current data, request more return 0, empty, nil } found := advance != notfound if found { pos += w + advance continue } } // https://unicode.org/reports/tr29/#WB7c if current.is(_HebrewLetter) && lastExIgnore.is(_DoubleQuote) && lastLastExIgnore.is(_HebrewLetter) { pos += w continue } // https://unicode.org/reports/tr29/#WB11 if current.is(_Numeric) && lastExIgnore.is(_MidNum|_MidNumLetQ) && lastLastExIgnore.is(_Numeric) { pos += w continue } // https://unicode.org/reports/tr29/#WB12 if current.is(_MidNum|_MidNumLetQ) && lastExIgnore.is(_Numeric) { advance, more := subsequent(_Numeric, data[pos+w:], atEOF) if more { // Token extends past current data, request more return 0, empty, nil } if advance != notfound { pos += w + advance continue } } // https://unicode.org/reports/tr29/#WB13 if current.is(_Katakana) && lastExIgnore.is(_Katakana) { pos += w continue } // https://unicode.org/reports/tr29/#WB13a if current.is(_ExtendNumLet) && lastExIgnore.is(_AHLetter|_Numeric|_Katakana|_ExtendNumLet) { pos += w continue } // https://unicode.org/reports/tr29/#WB13b if current.is(_AHLetter|_Numeric|_Katakana) && lastExIgnore.is(_ExtendNumLet) { pos += w continue } // https://unicode.org/reports/tr29/#WB15 and // https://unicode.org/reports/tr29/#WB16 if current.is(_RegionalIndicator) && lastExIgnore.is(_RegionalIndicator) { regionalIndicatorCount++ odd := regionalIndicatorCount%2 == 1 if odd { pos += w continue } } // https://unicode.org/reports/tr29/#WB999 // If we fall through all the above rules, it's a word break break } return pos, data[:pos], nil } golang-github-clipperhouse-uax29-2.7.0/words/string_test.go000066400000000000000000000162471515045622700237700ustar00rootroot00000000000000package words_test import ( "bytes" "reflect" "testing" "unicode/utf8" "github.com/clipperhouse/uax29/v2/testdata" "github.com/clipperhouse/uax29/v2/words" ) func TestStringUnicode(t *testing.T) { t.Parallel() // From the Unicode test suite; see the gen/ folder. var passed, failed int for _, test := range unicodeTests { test := test var all []string tokens := words.FromString(string(test.input)) for tokens.Next() { all = append(all, tokens.Value()) } expected := make([]string, len(test.expected)) for i, v := range test.expected { expected[i] = string(v) } if !reflect.DeepEqual(all, expected) { failed++ t.Errorf(` for input %v expected %v got %v spec %s`, test.input, test.expected, all, test.comment) } else { passed++ } } if len(unicodeTests) != passed+failed { t.Errorf("Incomplete %d tests: passed %d, failed %d", len(unicodeTests), passed, failed) } } func TestStringRoundtrip(t *testing.T) { t.Parallel() const runs = 100 for i := 0; i < runs; i++ { input := string(getRandomBytes()) tokens := words.FromString(input) var output string for tokens.Next() { output += tokens.Value() } if output != input { t.Fatal("input bytes are not the same as output bytes") } } } func stringIterToSet(tokens *words.Iterator[string]) map[string]struct{} { founds := make(map[string]struct{}) for tokens.Next() { founds[tokens.Value()] = struct{}{} } return founds } func TestStringJoiners(t *testing.T) { s := string(joinersInput) tokens1 := words.FromString(s) founds1 := stringIterToSet(tokens1) tokens2 := words.FromString(s) stringJoiners := &words.Joiners[string]{ Middle: []rune("@-/"), Leading: []rune("#."), } tokens2.Joiners(stringJoiners) founds2 := stringIterToSet(tokens2) for _, test := range joinersTests { _, found1 := founds1[test.input] if found1 != test.found1 { t.Fatalf("For %q, expected %t for found in non-config iterator, but got %t", test.input, test.found1, found1) } _, found2 := founds2[test.input] if found2 != test.found2 { t.Fatalf("For %q, expected %t for found in iterator with joiners, but got %t", test.input, test.found2, found2) } } } func TestStringInvalidUTF8(t *testing.T) { t.Parallel() // For background, see internal/testdata/UTF-8-test.txt, or: // https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt // Btw, don't edit UTF-8-test.txt: your editor might turn it into valid UTF-8! input, err := testdata.InvalidUTF8() if err != nil { t.Error(err) } if utf8.Valid(input) { t.Error("input file should not be valid utf8") } sc := words.FromString(string(input)) var output string for sc.Next() { output += sc.Value() } if output != string(input) { t.Fatalf("input bytes are not the same as output bytes") } } func TestFirst(t *testing.T) { t.Parallel() tests := []struct { name string input string expected string }{ { name: "ASCII word", input: "hello world", expected: "hello", }, { name: "ASCII word followed by space at end", input: "hello ", expected: "hello", }, { name: "Unicode word", input: "héllo world", expected: "héllo", }, { name: "CJK characters", input: "日本語 text", expected: "日", }, { name: "empty string", input: "", expected: "", }, { name: "single ASCII word", input: "hello", expected: "hello", }, { name: "pure ASCII alphanumeric", input: "abc123 def456", expected: "abc123", }, { name: "starts with space", input: " hello", expected: " ", }, { name: "starts with punctuation", input: "!hello", expected: "!", }, { name: "contraction", input: "don't stop", expected: "don't", }, } for _, tt := range tests { t.Run(tt.name+"/string", func(t *testing.T) { iter := words.FromString(tt.input) got := iter.First() if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) t.Run(tt.name+"/bytes", func(t *testing.T) { iter := words.FromBytes([]byte(tt.input)) got := string(iter.First()) if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) } } func TestFirstASCIIOptimization(t *testing.T) { t.Parallel() tests := []struct { name string input string expected string }{ // Pure ASCII hot path cases { name: "ASCII word followed by space then end", input: "hello ", expected: "hello", }, { name: "ASCII word at end of data", input: "hello", expected: "hello", }, { name: "multiple ASCII words picks first", input: "hello world foo", expected: "hello", }, // Fallback to splitFunc cases { name: "ASCII followed by non-space punctuation", input: "hello,world", expected: "hello", }, { name: "ASCII followed by non-ASCII", input: "hello世界", expected: "hello", }, { name: "ASCII with mid-word apostrophe", input: "don't", expected: "don't", }, { name: "ASCII with hyphen not supported by hot path", input: "self-test foo", expected: "self", }, // Single character edge cases { name: "single ASCII letter", input: "a", expected: "a", }, { name: "single ASCII digit", input: "5", expected: "5", }, { name: "single space", input: " ", expected: " ", }, // Non-ASCII at start (no hot path) { name: "starts with non-ASCII letter", input: "éclair is tasty", expected: "éclair", }, { name: "starts with emoji", input: "🎉 party", expected: "🎉", }, // Numbers { name: "pure digits", input: "12345 next", expected: "12345", }, { name: "mixed alphanumeric", input: "abc123def ", expected: "abc123def", }, // Edge: ASCII then combining character { name: "ASCII then combining mark", input: "e\u0301cole", // é as e + combining acute expected: "e\u0301cole", }, } for _, tt := range tests { t.Run(tt.name+"/string", func(t *testing.T) { iter := words.FromString(tt.input) got := iter.First() if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) t.Run(tt.name+"/bytes", func(t *testing.T) { iter := words.FromBytes([]byte(tt.input)) got := string(iter.First()) if got != tt.expected { t.Errorf("expected %q, got %q", tt.expected, got) } }) } } func BenchmarkString(b *testing.B) { file, err := testdata.Sample() if err != nil { b.Error(err) } s := string(file) b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := words.FromString(s) c := 0 for tokens.Next() { _ = tokens.Value() c++ } b.ReportMetric(float64(c), "tokens") } } func BenchmarkStringUnicodeTests(b *testing.B) { var buf bytes.Buffer for _, test := range unicodeTests { buf.Write(test.input) } file := buf.Bytes() s := string(file) b.ResetTimer() b.SetBytes(int64(len(file))) for i := 0; i < b.N; i++ { tokens := words.FromString(s) c := 0 for tokens.Next() { _ = tokens.Value() c++ } b.ReportMetric(float64(c), "tokens") } } golang-github-clipperhouse-uax29-2.7.0/words/trie.go000066400000000000000000010414631515045622700223650ustar00rootroot00000000000000package words // generated by github.com/clipperhouse/uax29/v2 // from https://www.unicode.org/Public/17.0.0/ucd/auxiliary/WordBreakProperty.txt type property uint32 const ( _ALetter property = 1 << iota _BleveIdeographic _CR _DoubleQuote _Extend _ExtendNumLet _ExtendedPictographic _Format _HebrewLetter _Katakana _LF _MidLetter _MidNum _MidNumLet _Newline _Numeric _RegionalIndicator _SingleQuote _WSegSpace _ZWJ ) // 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 lookup[T ~string | ~[]byte](s T) (v property, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII return wordsValues[c0], 1 case c0 < 0xC2: return 0, 1 // Illegal UTF-8: not a starter, not ASCII. case c0 < 0xE0: // 2-byte UTF-8 if len(s) < 2 { return 0, 0 } i := wordsIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c1), 2 case c0 < 0xF0: // 3-byte UTF-8 if len(s) < 3 { return 0, 0 } i := wordsIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = wordsIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c2), 3 case c0 < 0xF8: // 4-byte UTF-8 if len(s) < 4 { return 0, 0 } i := wordsIndex[c0] c1 := s[1] if c1 < 0x80 || 0xC0 <= c1 { return 0, 1 // Illegal UTF-8: not a continuation byte. } o := uint32(i)<<6 + uint32(c1) i = wordsIndex[o] c2 := s[2] if c2 < 0x80 || 0xC0 <= c2 { return 0, 2 // Illegal UTF-8: not a continuation byte. } o = uint32(i)<<6 + uint32(c2) i = wordsIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // wordsTrie. Total size: 100608 bytes (98.25 KiB). Checksum: 15f1c04c89caf743. // type wordsTrie struct { } // func newWordsTrie(i int) *wordsTrie { // return &wordsTrie{} // } // lookupValue determines the type of block n and looks up the value for b. func lookupValue(n uint32, b byte) property { switch { default: return property(wordsValues[n<<6+uint32(b)]) } } // wordsValues: 375 blocks, 24000 entries, 96000 bytes // The third block is the zero block. var wordsValues = [24000]property{ // Block 0x0, offset 0x0 0x0a: 0x0400, 0x0b: 0x4000, 0x0c: 0x4000, 0x0d: 0x0004, 0x20: 0x40000, 0x22: 0x0008, 0x27: 0x20000, 0x2c: 0x1000, 0x2e: 0x2000, 0x30: 0x8000, 0x31: 0x8000, 0x32: 0x8000, 0x33: 0x8000, 0x34: 0x8000, 0x35: 0x8000, 0x36: 0x8000, 0x37: 0x8000, 0x38: 0x8000, 0x39: 0x8000, 0x3a: 0x0800, 0x3b: 0x1000, // Block 0x1, offset 0x40 0x41: 0x0001, 0x42: 0x0001, 0x43: 0x0001, 0x44: 0x0001, 0x45: 0x0001, 0x46: 0x0001, 0x47: 0x0001, 0x48: 0x0001, 0x49: 0x0001, 0x4a: 0x0001, 0x4b: 0x0001, 0x4c: 0x0001, 0x4d: 0x0001, 0x4e: 0x0001, 0x4f: 0x0001, 0x50: 0x0001, 0x51: 0x0001, 0x52: 0x0001, 0x53: 0x0001, 0x54: 0x0001, 0x55: 0x0001, 0x56: 0x0001, 0x57: 0x0001, 0x58: 0x0001, 0x59: 0x0001, 0x5a: 0x0001, 0x5f: 0x0020, 0x61: 0x0001, 0x62: 0x0001, 0x63: 0x0001, 0x64: 0x0001, 0x65: 0x0001, 0x66: 0x0001, 0x67: 0x0001, 0x68: 0x0001, 0x69: 0x0001, 0x6a: 0x0001, 0x6b: 0x0001, 0x6c: 0x0001, 0x6d: 0x0001, 0x6e: 0x0001, 0x6f: 0x0001, 0x70: 0x0001, 0x71: 0x0001, 0x72: 0x0001, 0x73: 0x0001, 0x74: 0x0001, 0x75: 0x0001, 0x76: 0x0001, 0x77: 0x0001, 0x78: 0x0001, 0x79: 0x0001, 0x7a: 0x0001, // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc5: 0x4000, 0xe9: 0x0040, 0xea: 0x0001, 0xed: 0x0080, 0xee: 0x0040, 0xf5: 0x0001, 0xf7: 0x0800, 0xf8: 0x0001, 0xfa: 0x0001, // Block 0x4, offset 0x100 0x100: 0x0001, 0x101: 0x0001, 0x102: 0x0001, 0x103: 0x0001, 0x104: 0x0001, 0x105: 0x0001, 0x106: 0x0001, 0x107: 0x0001, 0x108: 0x0001, 0x109: 0x0001, 0x10a: 0x0001, 0x10b: 0x0001, 0x10c: 0x0001, 0x10d: 0x0001, 0x10e: 0x0001, 0x10f: 0x0001, 0x110: 0x0001, 0x111: 0x0001, 0x112: 0x0001, 0x113: 0x0001, 0x114: 0x0001, 0x115: 0x0001, 0x116: 0x0001, 0x118: 0x0001, 0x119: 0x0001, 0x11a: 0x0001, 0x11b: 0x0001, 0x11c: 0x0001, 0x11d: 0x0001, 0x11e: 0x0001, 0x11f: 0x0001, 0x120: 0x0001, 0x121: 0x0001, 0x122: 0x0001, 0x123: 0x0001, 0x124: 0x0001, 0x125: 0x0001, 0x126: 0x0001, 0x127: 0x0001, 0x128: 0x0001, 0x129: 0x0001, 0x12a: 0x0001, 0x12b: 0x0001, 0x12c: 0x0001, 0x12d: 0x0001, 0x12e: 0x0001, 0x12f: 0x0001, 0x130: 0x0001, 0x131: 0x0001, 0x132: 0x0001, 0x133: 0x0001, 0x134: 0x0001, 0x135: 0x0001, 0x136: 0x0001, 0x138: 0x0001, 0x139: 0x0001, 0x13a: 0x0001, 0x13b: 0x0001, 0x13c: 0x0001, 0x13d: 0x0001, 0x13e: 0x0001, 0x13f: 0x0001, // Block 0x5, offset 0x140 0x140: 0x0001, 0x141: 0x0001, 0x142: 0x0001, 0x143: 0x0001, 0x144: 0x0001, 0x145: 0x0001, 0x146: 0x0001, 0x147: 0x0001, 0x148: 0x0001, 0x149: 0x0001, 0x14a: 0x0001, 0x14b: 0x0001, 0x14c: 0x0001, 0x14d: 0x0001, 0x14e: 0x0001, 0x14f: 0x0001, 0x150: 0x0001, 0x151: 0x0001, 0x152: 0x0001, 0x153: 0x0001, 0x154: 0x0001, 0x155: 0x0001, 0x156: 0x0001, 0x157: 0x0001, 0x158: 0x0001, 0x159: 0x0001, 0x15a: 0x0001, 0x15b: 0x0001, 0x15c: 0x0001, 0x15d: 0x0001, 0x15e: 0x0001, 0x15f: 0x0001, 0x160: 0x0001, 0x161: 0x0001, 0x162: 0x0001, 0x163: 0x0001, 0x164: 0x0001, 0x165: 0x0001, 0x166: 0x0001, 0x167: 0x0001, 0x168: 0x0001, 0x169: 0x0001, 0x16a: 0x0001, 0x16b: 0x0001, 0x16c: 0x0001, 0x16d: 0x0001, 0x16e: 0x0001, 0x16f: 0x0001, 0x170: 0x0001, 0x171: 0x0001, 0x172: 0x0001, 0x173: 0x0001, 0x174: 0x0001, 0x175: 0x0001, 0x176: 0x0001, 0x177: 0x0001, 0x178: 0x0001, 0x179: 0x0001, 0x17a: 0x0001, 0x17b: 0x0001, 0x17c: 0x0001, 0x17d: 0x0001, 0x17e: 0x0001, 0x17f: 0x0001, // Block 0x6, offset 0x180 0x180: 0x0001, 0x181: 0x0001, 0x182: 0x0001, 0x183: 0x0001, 0x184: 0x0001, 0x185: 0x0001, 0x186: 0x0001, 0x187: 0x0001, 0x188: 0x0001, 0x189: 0x0001, 0x18a: 0x0001, 0x18b: 0x0001, 0x18c: 0x0001, 0x18d: 0x0001, 0x18e: 0x0001, 0x18f: 0x0001, 0x190: 0x0001, 0x191: 0x0001, 0x192: 0x0001, 0x193: 0x0001, 0x194: 0x0001, 0x195: 0x0001, 0x196: 0x0001, 0x197: 0x0001, 0x19e: 0x0001, 0x19f: 0x0001, 0x1a0: 0x0001, 0x1a1: 0x0001, 0x1a2: 0x0001, 0x1a3: 0x0001, 0x1a4: 0x0001, 0x1a5: 0x0001, 0x1a6: 0x0001, 0x1a7: 0x0001, 0x1a8: 0x0001, 0x1a9: 0x0001, 0x1aa: 0x0001, 0x1ab: 0x0001, 0x1ac: 0x0001, 0x1ad: 0x0001, 0x1ae: 0x0001, 0x1af: 0x0001, 0x1b0: 0x0001, 0x1b1: 0x0001, 0x1b2: 0x0001, 0x1b3: 0x0001, 0x1b4: 0x0001, 0x1b5: 0x0001, 0x1b6: 0x0001, 0x1b7: 0x0001, 0x1b8: 0x0001, 0x1b9: 0x0001, 0x1ba: 0x0001, 0x1bb: 0x0001, 0x1bc: 0x0001, 0x1bd: 0x0001, 0x1be: 0x0001, 0x1bf: 0x0001, // Block 0x7, offset 0x1c0 0x1c0: 0x0010, 0x1c1: 0x0010, 0x1c2: 0x0010, 0x1c3: 0x0010, 0x1c4: 0x0010, 0x1c5: 0x0010, 0x1c6: 0x0010, 0x1c7: 0x0010, 0x1c8: 0x0010, 0x1c9: 0x0010, 0x1ca: 0x0010, 0x1cb: 0x0010, 0x1cc: 0x0010, 0x1cd: 0x0010, 0x1ce: 0x0010, 0x1cf: 0x0010, 0x1d0: 0x0010, 0x1d1: 0x0010, 0x1d2: 0x0010, 0x1d3: 0x0010, 0x1d4: 0x0010, 0x1d5: 0x0010, 0x1d6: 0x0010, 0x1d7: 0x0010, 0x1d8: 0x0010, 0x1d9: 0x0010, 0x1da: 0x0010, 0x1db: 0x0010, 0x1dc: 0x0010, 0x1dd: 0x0010, 0x1de: 0x0010, 0x1df: 0x0010, 0x1e0: 0x0010, 0x1e1: 0x0010, 0x1e2: 0x0010, 0x1e3: 0x0010, 0x1e4: 0x0010, 0x1e5: 0x0010, 0x1e6: 0x0010, 0x1e7: 0x0010, 0x1e8: 0x0010, 0x1e9: 0x0010, 0x1ea: 0x0010, 0x1eb: 0x0010, 0x1ec: 0x0010, 0x1ed: 0x0010, 0x1ee: 0x0010, 0x1ef: 0x0010, 0x1f0: 0x0010, 0x1f1: 0x0010, 0x1f2: 0x0010, 0x1f3: 0x0010, 0x1f4: 0x0010, 0x1f5: 0x0010, 0x1f6: 0x0010, 0x1f7: 0x0010, 0x1f8: 0x0010, 0x1f9: 0x0010, 0x1fa: 0x0010, 0x1fb: 0x0010, 0x1fc: 0x0010, 0x1fd: 0x0010, 0x1fe: 0x0010, 0x1ff: 0x0010, // Block 0x8, offset 0x200 0x200: 0x0010, 0x201: 0x0010, 0x202: 0x0010, 0x203: 0x0010, 0x204: 0x0010, 0x205: 0x0010, 0x206: 0x0010, 0x207: 0x0010, 0x208: 0x0010, 0x209: 0x0010, 0x20a: 0x0010, 0x20b: 0x0010, 0x20c: 0x0010, 0x20d: 0x0010, 0x20e: 0x0010, 0x20f: 0x0010, 0x210: 0x0010, 0x211: 0x0010, 0x212: 0x0010, 0x213: 0x0010, 0x214: 0x0010, 0x215: 0x0010, 0x216: 0x0010, 0x217: 0x0010, 0x218: 0x0010, 0x219: 0x0010, 0x21a: 0x0010, 0x21b: 0x0010, 0x21c: 0x0010, 0x21d: 0x0010, 0x21e: 0x0010, 0x21f: 0x0010, 0x220: 0x0010, 0x221: 0x0010, 0x222: 0x0010, 0x223: 0x0010, 0x224: 0x0010, 0x225: 0x0010, 0x226: 0x0010, 0x227: 0x0010, 0x228: 0x0010, 0x229: 0x0010, 0x22a: 0x0010, 0x22b: 0x0010, 0x22c: 0x0010, 0x22d: 0x0010, 0x22e: 0x0010, 0x22f: 0x0010, 0x230: 0x0001, 0x231: 0x0001, 0x232: 0x0001, 0x233: 0x0001, 0x234: 0x0001, 0x236: 0x0001, 0x237: 0x0001, 0x23a: 0x0001, 0x23b: 0x0001, 0x23c: 0x0001, 0x23d: 0x0001, 0x23e: 0x1000, 0x23f: 0x0001, // Block 0x9, offset 0x240 0x246: 0x0001, 0x247: 0x0800, 0x248: 0x0001, 0x249: 0x0001, 0x24a: 0x0001, 0x24c: 0x0001, 0x24e: 0x0001, 0x24f: 0x0001, 0x250: 0x0001, 0x251: 0x0001, 0x252: 0x0001, 0x253: 0x0001, 0x254: 0x0001, 0x255: 0x0001, 0x256: 0x0001, 0x257: 0x0001, 0x258: 0x0001, 0x259: 0x0001, 0x25a: 0x0001, 0x25b: 0x0001, 0x25c: 0x0001, 0x25d: 0x0001, 0x25e: 0x0001, 0x25f: 0x0001, 0x260: 0x0001, 0x261: 0x0001, 0x263: 0x0001, 0x264: 0x0001, 0x265: 0x0001, 0x266: 0x0001, 0x267: 0x0001, 0x268: 0x0001, 0x269: 0x0001, 0x26a: 0x0001, 0x26b: 0x0001, 0x26c: 0x0001, 0x26d: 0x0001, 0x26e: 0x0001, 0x26f: 0x0001, 0x270: 0x0001, 0x271: 0x0001, 0x272: 0x0001, 0x273: 0x0001, 0x274: 0x0001, 0x275: 0x0001, 0x276: 0x0001, 0x277: 0x0001, 0x278: 0x0001, 0x279: 0x0001, 0x27a: 0x0001, 0x27b: 0x0001, 0x27c: 0x0001, 0x27d: 0x0001, 0x27e: 0x0001, 0x27f: 0x0001, // Block 0xa, offset 0x280 0x280: 0x0001, 0x281: 0x0001, 0x282: 0x0001, 0x283: 0x0001, 0x284: 0x0001, 0x285: 0x0001, 0x286: 0x0001, 0x287: 0x0001, 0x288: 0x0001, 0x289: 0x0001, 0x28a: 0x0001, 0x28b: 0x0001, 0x28c: 0x0001, 0x28d: 0x0001, 0x28e: 0x0001, 0x28f: 0x0001, 0x290: 0x0001, 0x291: 0x0001, 0x292: 0x0001, 0x293: 0x0001, 0x294: 0x0001, 0x295: 0x0001, 0x296: 0x0001, 0x297: 0x0001, 0x298: 0x0001, 0x299: 0x0001, 0x29a: 0x0001, 0x29b: 0x0001, 0x29c: 0x0001, 0x29d: 0x0001, 0x29e: 0x0001, 0x29f: 0x0001, 0x2a0: 0x0001, 0x2a1: 0x0001, 0x2a2: 0x0001, 0x2a3: 0x0001, 0x2a4: 0x0001, 0x2a5: 0x0001, 0x2a6: 0x0001, 0x2a7: 0x0001, 0x2a8: 0x0001, 0x2a9: 0x0001, 0x2aa: 0x0001, 0x2ab: 0x0001, 0x2ac: 0x0001, 0x2ad: 0x0001, 0x2ae: 0x0001, 0x2af: 0x0001, 0x2b0: 0x0001, 0x2b1: 0x0001, 0x2b2: 0x0001, 0x2b3: 0x0001, 0x2b4: 0x0001, 0x2b5: 0x0001, 0x2b7: 0x0001, 0x2b8: 0x0001, 0x2b9: 0x0001, 0x2ba: 0x0001, 0x2bb: 0x0001, 0x2bc: 0x0001, 0x2bd: 0x0001, 0x2be: 0x0001, 0x2bf: 0x0001, // Block 0xb, offset 0x2c0 0x2c0: 0x0001, 0x2c1: 0x0001, 0x2c3: 0x0010, 0x2c4: 0x0010, 0x2c5: 0x0010, 0x2c6: 0x0010, 0x2c7: 0x0010, 0x2c8: 0x0010, 0x2c9: 0x0010, 0x2ca: 0x0001, 0x2cb: 0x0001, 0x2cc: 0x0001, 0x2cd: 0x0001, 0x2ce: 0x0001, 0x2cf: 0x0001, 0x2d0: 0x0001, 0x2d1: 0x0001, 0x2d2: 0x0001, 0x2d3: 0x0001, 0x2d4: 0x0001, 0x2d5: 0x0001, 0x2d6: 0x0001, 0x2d7: 0x0001, 0x2d8: 0x0001, 0x2d9: 0x0001, 0x2da: 0x0001, 0x2db: 0x0001, 0x2dc: 0x0001, 0x2dd: 0x0001, 0x2de: 0x0001, 0x2df: 0x0001, 0x2e0: 0x0001, 0x2e1: 0x0001, 0x2e2: 0x0001, 0x2e3: 0x0001, 0x2e4: 0x0001, 0x2e5: 0x0001, 0x2e6: 0x0001, 0x2e7: 0x0001, 0x2e8: 0x0001, 0x2e9: 0x0001, 0x2ea: 0x0001, 0x2eb: 0x0001, 0x2ec: 0x0001, 0x2ed: 0x0001, 0x2ee: 0x0001, 0x2ef: 0x0001, 0x2f0: 0x0001, 0x2f1: 0x0001, 0x2f2: 0x0001, 0x2f3: 0x0001, 0x2f4: 0x0001, 0x2f5: 0x0001, 0x2f6: 0x0001, 0x2f7: 0x0001, 0x2f8: 0x0001, 0x2f9: 0x0001, 0x2fa: 0x0001, 0x2fb: 0x0001, 0x2fc: 0x0001, 0x2fd: 0x0001, 0x2fe: 0x0001, 0x2ff: 0x0001, // Block 0xc, offset 0x300 0x300: 0x0001, 0x301: 0x0001, 0x302: 0x0001, 0x303: 0x0001, 0x304: 0x0001, 0x305: 0x0001, 0x306: 0x0001, 0x307: 0x0001, 0x308: 0x0001, 0x309: 0x0001, 0x30a: 0x0001, 0x30b: 0x0001, 0x30c: 0x0001, 0x30d: 0x0001, 0x30e: 0x0001, 0x30f: 0x0001, 0x310: 0x0001, 0x311: 0x0001, 0x312: 0x0001, 0x313: 0x0001, 0x314: 0x0001, 0x315: 0x0001, 0x316: 0x0001, 0x317: 0x0001, 0x318: 0x0001, 0x319: 0x0001, 0x31a: 0x0001, 0x31b: 0x0001, 0x31c: 0x0001, 0x31d: 0x0001, 0x31e: 0x0001, 0x31f: 0x0001, 0x320: 0x0001, 0x321: 0x0001, 0x322: 0x0001, 0x323: 0x0001, 0x324: 0x0001, 0x325: 0x0001, 0x326: 0x0001, 0x327: 0x0001, 0x328: 0x0001, 0x329: 0x0001, 0x32a: 0x0001, 0x32b: 0x0001, 0x32c: 0x0001, 0x32d: 0x0001, 0x32e: 0x0001, 0x32f: 0x0001, 0x331: 0x0001, 0x332: 0x0001, 0x333: 0x0001, 0x334: 0x0001, 0x335: 0x0001, 0x336: 0x0001, 0x337: 0x0001, 0x338: 0x0001, 0x339: 0x0001, 0x33a: 0x0001, 0x33b: 0x0001, 0x33c: 0x0001, 0x33d: 0x0001, 0x33e: 0x0001, 0x33f: 0x0001, // Block 0xd, offset 0x340 0x340: 0x0001, 0x341: 0x0001, 0x342: 0x0001, 0x343: 0x0001, 0x344: 0x0001, 0x345: 0x0001, 0x346: 0x0001, 0x347: 0x0001, 0x348: 0x0001, 0x349: 0x0001, 0x34a: 0x0001, 0x34b: 0x0001, 0x34c: 0x0001, 0x34d: 0x0001, 0x34e: 0x0001, 0x34f: 0x0001, 0x350: 0x0001, 0x351: 0x0001, 0x352: 0x0001, 0x353: 0x0001, 0x354: 0x0001, 0x355: 0x0001, 0x356: 0x0001, 0x359: 0x0001, 0x35a: 0x0001, 0x35b: 0x0001, 0x35c: 0x0001, 0x35e: 0x0001, 0x35f: 0x0800, 0x360: 0x0001, 0x361: 0x0001, 0x362: 0x0001, 0x363: 0x0001, 0x364: 0x0001, 0x365: 0x0001, 0x366: 0x0001, 0x367: 0x0001, 0x368: 0x0001, 0x369: 0x0001, 0x36a: 0x0001, 0x36b: 0x0001, 0x36c: 0x0001, 0x36d: 0x0001, 0x36e: 0x0001, 0x36f: 0x0001, 0x370: 0x0001, 0x371: 0x0001, 0x372: 0x0001, 0x373: 0x0001, 0x374: 0x0001, 0x375: 0x0001, 0x376: 0x0001, 0x377: 0x0001, 0x378: 0x0001, 0x379: 0x0001, 0x37a: 0x0001, 0x37b: 0x0001, 0x37c: 0x0001, 0x37d: 0x0001, 0x37e: 0x0001, 0x37f: 0x0001, // Block 0xe, offset 0x380 0x380: 0x0001, 0x381: 0x0001, 0x382: 0x0001, 0x383: 0x0001, 0x384: 0x0001, 0x385: 0x0001, 0x386: 0x0001, 0x387: 0x0001, 0x388: 0x0001, 0x389: 0x1000, 0x38a: 0x0001, 0x391: 0x0010, 0x392: 0x0010, 0x393: 0x0010, 0x394: 0x0010, 0x395: 0x0010, 0x396: 0x0010, 0x397: 0x0010, 0x398: 0x0010, 0x399: 0x0010, 0x39a: 0x0010, 0x39b: 0x0010, 0x39c: 0x0010, 0x39d: 0x0010, 0x39e: 0x0010, 0x39f: 0x0010, 0x3a0: 0x0010, 0x3a1: 0x0010, 0x3a2: 0x0010, 0x3a3: 0x0010, 0x3a4: 0x0010, 0x3a5: 0x0010, 0x3a6: 0x0010, 0x3a7: 0x0010, 0x3a8: 0x0010, 0x3a9: 0x0010, 0x3aa: 0x0010, 0x3ab: 0x0010, 0x3ac: 0x0010, 0x3ad: 0x0010, 0x3ae: 0x0010, 0x3af: 0x0010, 0x3b0: 0x0010, 0x3b1: 0x0010, 0x3b2: 0x0010, 0x3b3: 0x0010, 0x3b4: 0x0010, 0x3b5: 0x0010, 0x3b6: 0x0010, 0x3b7: 0x0010, 0x3b8: 0x0010, 0x3b9: 0x0010, 0x3ba: 0x0010, 0x3bb: 0x0010, 0x3bc: 0x0010, 0x3bd: 0x0010, 0x3bf: 0x0010, // Block 0xf, offset 0x3c0 0x3c1: 0x0010, 0x3c2: 0x0010, 0x3c4: 0x0010, 0x3c5: 0x0010, 0x3c7: 0x0010, 0x3d0: 0x0100, 0x3d1: 0x0100, 0x3d2: 0x0100, 0x3d3: 0x0100, 0x3d4: 0x0100, 0x3d5: 0x0100, 0x3d6: 0x0100, 0x3d7: 0x0100, 0x3d8: 0x0100, 0x3d9: 0x0100, 0x3da: 0x0100, 0x3db: 0x0100, 0x3dc: 0x0100, 0x3dd: 0x0100, 0x3de: 0x0100, 0x3df: 0x0100, 0x3e0: 0x0100, 0x3e1: 0x0100, 0x3e2: 0x0100, 0x3e3: 0x0100, 0x3e4: 0x0100, 0x3e5: 0x0100, 0x3e6: 0x0100, 0x3e7: 0x0100, 0x3e8: 0x0100, 0x3e9: 0x0100, 0x3ea: 0x0100, 0x3ef: 0x0100, 0x3f0: 0x0100, 0x3f1: 0x0100, 0x3f2: 0x0100, 0x3f3: 0x0001, 0x3f4: 0x0800, // Block 0x10, offset 0x400 0x400: 0x8000, 0x401: 0x8000, 0x402: 0x8000, 0x403: 0x8000, 0x404: 0x8000, 0x405: 0x8000, 0x40c: 0x1000, 0x40d: 0x1000, 0x410: 0x0010, 0x411: 0x0010, 0x412: 0x0010, 0x413: 0x0010, 0x414: 0x0010, 0x415: 0x0010, 0x416: 0x0010, 0x417: 0x0010, 0x418: 0x0010, 0x419: 0x0010, 0x41a: 0x0010, 0x41c: 0x0080, 0x420: 0x0001, 0x421: 0x0001, 0x422: 0x0001, 0x423: 0x0001, 0x424: 0x0001, 0x425: 0x0001, 0x426: 0x0001, 0x427: 0x0001, 0x428: 0x0001, 0x429: 0x0001, 0x42a: 0x0001, 0x42b: 0x0001, 0x42c: 0x0001, 0x42d: 0x0001, 0x42e: 0x0001, 0x42f: 0x0001, 0x430: 0x0001, 0x431: 0x0001, 0x432: 0x0001, 0x433: 0x0001, 0x434: 0x0001, 0x435: 0x0001, 0x436: 0x0001, 0x437: 0x0001, 0x438: 0x0001, 0x439: 0x0001, 0x43a: 0x0001, 0x43b: 0x0001, 0x43c: 0x0001, 0x43d: 0x0001, 0x43e: 0x0001, 0x43f: 0x0001, // Block 0x11, offset 0x440 0x440: 0x0001, 0x441: 0x0001, 0x442: 0x0001, 0x443: 0x0001, 0x444: 0x0001, 0x445: 0x0001, 0x446: 0x0001, 0x447: 0x0001, 0x448: 0x0001, 0x449: 0x0001, 0x44a: 0x0001, 0x44b: 0x0010, 0x44c: 0x0010, 0x44d: 0x0010, 0x44e: 0x0010, 0x44f: 0x0010, 0x450: 0x0010, 0x451: 0x0010, 0x452: 0x0010, 0x453: 0x0010, 0x454: 0x0010, 0x455: 0x0010, 0x456: 0x0010, 0x457: 0x0010, 0x458: 0x0010, 0x459: 0x0010, 0x45a: 0x0010, 0x45b: 0x0010, 0x45c: 0x0010, 0x45d: 0x0010, 0x45e: 0x0010, 0x45f: 0x0010, 0x460: 0x8000, 0x461: 0x8000, 0x462: 0x8000, 0x463: 0x8000, 0x464: 0x8000, 0x465: 0x8000, 0x466: 0x8000, 0x467: 0x8000, 0x468: 0x8000, 0x469: 0x8000, 0x46b: 0x8000, 0x46c: 0x1000, 0x46e: 0x0001, 0x46f: 0x0001, 0x470: 0x0010, 0x471: 0x0001, 0x472: 0x0001, 0x473: 0x0001, 0x474: 0x0001, 0x475: 0x0001, 0x476: 0x0001, 0x477: 0x0001, 0x478: 0x0001, 0x479: 0x0001, 0x47a: 0x0001, 0x47b: 0x0001, 0x47c: 0x0001, 0x47d: 0x0001, 0x47e: 0x0001, 0x47f: 0x0001, // Block 0x12, offset 0x480 0x480: 0x0001, 0x481: 0x0001, 0x482: 0x0001, 0x483: 0x0001, 0x484: 0x0001, 0x485: 0x0001, 0x486: 0x0001, 0x487: 0x0001, 0x488: 0x0001, 0x489: 0x0001, 0x48a: 0x0001, 0x48b: 0x0001, 0x48c: 0x0001, 0x48d: 0x0001, 0x48e: 0x0001, 0x48f: 0x0001, 0x490: 0x0001, 0x491: 0x0001, 0x492: 0x0001, 0x493: 0x0001, 0x495: 0x0001, 0x496: 0x0010, 0x497: 0x0010, 0x498: 0x0010, 0x499: 0x0010, 0x49a: 0x0010, 0x49b: 0x0010, 0x49c: 0x0010, 0x49d: 0x8000, 0x49f: 0x0010, 0x4a0: 0x0010, 0x4a1: 0x0010, 0x4a2: 0x0010, 0x4a3: 0x0010, 0x4a4: 0x0010, 0x4a5: 0x0001, 0x4a6: 0x0001, 0x4a7: 0x0010, 0x4a8: 0x0010, 0x4aa: 0x0010, 0x4ab: 0x0010, 0x4ac: 0x0010, 0x4ad: 0x0010, 0x4ae: 0x0001, 0x4af: 0x0001, 0x4b0: 0x8000, 0x4b1: 0x8000, 0x4b2: 0x8000, 0x4b3: 0x8000, 0x4b4: 0x8000, 0x4b5: 0x8000, 0x4b6: 0x8000, 0x4b7: 0x8000, 0x4b8: 0x8000, 0x4b9: 0x8000, 0x4ba: 0x0001, 0x4bb: 0x0001, 0x4bc: 0x0001, 0x4bf: 0x0001, // Block 0x13, offset 0x4c0 0x4cf: 0x0001, 0x4d0: 0x0001, 0x4d1: 0x0010, 0x4d2: 0x0001, 0x4d3: 0x0001, 0x4d4: 0x0001, 0x4d5: 0x0001, 0x4d6: 0x0001, 0x4d7: 0x0001, 0x4d8: 0x0001, 0x4d9: 0x0001, 0x4da: 0x0001, 0x4db: 0x0001, 0x4dc: 0x0001, 0x4dd: 0x0001, 0x4de: 0x0001, 0x4df: 0x0001, 0x4e0: 0x0001, 0x4e1: 0x0001, 0x4e2: 0x0001, 0x4e3: 0x0001, 0x4e4: 0x0001, 0x4e5: 0x0001, 0x4e6: 0x0001, 0x4e7: 0x0001, 0x4e8: 0x0001, 0x4e9: 0x0001, 0x4ea: 0x0001, 0x4eb: 0x0001, 0x4ec: 0x0001, 0x4ed: 0x0001, 0x4ee: 0x0001, 0x4ef: 0x0001, 0x4f0: 0x0010, 0x4f1: 0x0010, 0x4f2: 0x0010, 0x4f3: 0x0010, 0x4f4: 0x0010, 0x4f5: 0x0010, 0x4f6: 0x0010, 0x4f7: 0x0010, 0x4f8: 0x0010, 0x4f9: 0x0010, 0x4fa: 0x0010, 0x4fb: 0x0010, 0x4fc: 0x0010, 0x4fd: 0x0010, 0x4fe: 0x0010, 0x4ff: 0x0010, // Block 0x14, offset 0x500 0x500: 0x0010, 0x501: 0x0010, 0x502: 0x0010, 0x503: 0x0010, 0x504: 0x0010, 0x505: 0x0010, 0x506: 0x0010, 0x507: 0x0010, 0x508: 0x0010, 0x509: 0x0010, 0x50a: 0x0010, 0x50d: 0x0001, 0x50e: 0x0001, 0x50f: 0x0001, 0x510: 0x0001, 0x511: 0x0001, 0x512: 0x0001, 0x513: 0x0001, 0x514: 0x0001, 0x515: 0x0001, 0x516: 0x0001, 0x517: 0x0001, 0x518: 0x0001, 0x519: 0x0001, 0x51a: 0x0001, 0x51b: 0x0001, 0x51c: 0x0001, 0x51d: 0x0001, 0x51e: 0x0001, 0x51f: 0x0001, 0x520: 0x0001, 0x521: 0x0001, 0x522: 0x0001, 0x523: 0x0001, 0x524: 0x0001, 0x525: 0x0001, 0x526: 0x0001, 0x527: 0x0001, 0x528: 0x0001, 0x529: 0x0001, 0x52a: 0x0001, 0x52b: 0x0001, 0x52c: 0x0001, 0x52d: 0x0001, 0x52e: 0x0001, 0x52f: 0x0001, 0x530: 0x0001, 0x531: 0x0001, 0x532: 0x0001, 0x533: 0x0001, 0x534: 0x0001, 0x535: 0x0001, 0x536: 0x0001, 0x537: 0x0001, 0x538: 0x0001, 0x539: 0x0001, 0x53a: 0x0001, 0x53b: 0x0001, 0x53c: 0x0001, 0x53d: 0x0001, 0x53e: 0x0001, 0x53f: 0x0001, // Block 0x15, offset 0x540 0x540: 0x0001, 0x541: 0x0001, 0x542: 0x0001, 0x543: 0x0001, 0x544: 0x0001, 0x545: 0x0001, 0x546: 0x0001, 0x547: 0x0001, 0x548: 0x0001, 0x549: 0x0001, 0x54a: 0x0001, 0x54b: 0x0001, 0x54c: 0x0001, 0x54d: 0x0001, 0x54e: 0x0001, 0x54f: 0x0001, 0x550: 0x0001, 0x551: 0x0001, 0x552: 0x0001, 0x553: 0x0001, 0x554: 0x0001, 0x555: 0x0001, 0x556: 0x0001, 0x557: 0x0001, 0x558: 0x0001, 0x559: 0x0001, 0x55a: 0x0001, 0x55b: 0x0001, 0x55c: 0x0001, 0x55d: 0x0001, 0x55e: 0x0001, 0x55f: 0x0001, 0x560: 0x0001, 0x561: 0x0001, 0x562: 0x0001, 0x563: 0x0001, 0x564: 0x0001, 0x565: 0x0001, 0x566: 0x0010, 0x567: 0x0010, 0x568: 0x0010, 0x569: 0x0010, 0x56a: 0x0010, 0x56b: 0x0010, 0x56c: 0x0010, 0x56d: 0x0010, 0x56e: 0x0010, 0x56f: 0x0010, 0x570: 0x0010, 0x571: 0x0001, // Block 0x16, offset 0x580 0x580: 0x8000, 0x581: 0x8000, 0x582: 0x8000, 0x583: 0x8000, 0x584: 0x8000, 0x585: 0x8000, 0x586: 0x8000, 0x587: 0x8000, 0x588: 0x8000, 0x589: 0x8000, 0x58a: 0x0001, 0x58b: 0x0001, 0x58c: 0x0001, 0x58d: 0x0001, 0x58e: 0x0001, 0x58f: 0x0001, 0x590: 0x0001, 0x591: 0x0001, 0x592: 0x0001, 0x593: 0x0001, 0x594: 0x0001, 0x595: 0x0001, 0x596: 0x0001, 0x597: 0x0001, 0x598: 0x0001, 0x599: 0x0001, 0x59a: 0x0001, 0x59b: 0x0001, 0x59c: 0x0001, 0x59d: 0x0001, 0x59e: 0x0001, 0x59f: 0x0001, 0x5a0: 0x0001, 0x5a1: 0x0001, 0x5a2: 0x0001, 0x5a3: 0x0001, 0x5a4: 0x0001, 0x5a5: 0x0001, 0x5a6: 0x0001, 0x5a7: 0x0001, 0x5a8: 0x0001, 0x5a9: 0x0001, 0x5aa: 0x0001, 0x5ab: 0x0010, 0x5ac: 0x0010, 0x5ad: 0x0010, 0x5ae: 0x0010, 0x5af: 0x0010, 0x5b0: 0x0010, 0x5b1: 0x0010, 0x5b2: 0x0010, 0x5b3: 0x0010, 0x5b4: 0x0001, 0x5b5: 0x0001, 0x5b8: 0x1000, 0x5ba: 0x0001, 0x5bd: 0x0010, // Block 0x17, offset 0x5c0 0x5c0: 0x0001, 0x5c1: 0x0001, 0x5c2: 0x0001, 0x5c3: 0x0001, 0x5c4: 0x0001, 0x5c5: 0x0001, 0x5c6: 0x0001, 0x5c7: 0x0001, 0x5c8: 0x0001, 0x5c9: 0x0001, 0x5ca: 0x0001, 0x5cb: 0x0001, 0x5cc: 0x0001, 0x5cd: 0x0001, 0x5ce: 0x0001, 0x5cf: 0x0001, 0x5d0: 0x0001, 0x5d1: 0x0001, 0x5d2: 0x0001, 0x5d3: 0x0001, 0x5d4: 0x0001, 0x5d5: 0x0001, 0x5d6: 0x0010, 0x5d7: 0x0010, 0x5d8: 0x0010, 0x5d9: 0x0010, 0x5da: 0x0001, 0x5db: 0x0010, 0x5dc: 0x0010, 0x5dd: 0x0010, 0x5de: 0x0010, 0x5df: 0x0010, 0x5e0: 0x0010, 0x5e1: 0x0010, 0x5e2: 0x0010, 0x5e3: 0x0010, 0x5e4: 0x0001, 0x5e5: 0x0010, 0x5e6: 0x0010, 0x5e7: 0x0010, 0x5e8: 0x0001, 0x5e9: 0x0010, 0x5ea: 0x0010, 0x5eb: 0x0010, 0x5ec: 0x0010, 0x5ed: 0x0010, // Block 0x18, offset 0x600 0x600: 0x0001, 0x601: 0x0001, 0x602: 0x0001, 0x603: 0x0001, 0x604: 0x0001, 0x605: 0x0001, 0x606: 0x0001, 0x607: 0x0001, 0x608: 0x0001, 0x609: 0x0001, 0x60a: 0x0001, 0x60b: 0x0001, 0x60c: 0x0001, 0x60d: 0x0001, 0x60e: 0x0001, 0x60f: 0x0001, 0x610: 0x0001, 0x611: 0x0001, 0x612: 0x0001, 0x613: 0x0001, 0x614: 0x0001, 0x615: 0x0001, 0x616: 0x0001, 0x617: 0x0001, 0x618: 0x0001, 0x619: 0x0010, 0x61a: 0x0010, 0x61b: 0x0010, 0x620: 0x0001, 0x621: 0x0001, 0x622: 0x0001, 0x623: 0x0001, 0x624: 0x0001, 0x625: 0x0001, 0x626: 0x0001, 0x627: 0x0001, 0x628: 0x0001, 0x629: 0x0001, 0x62a: 0x0001, 0x630: 0x0001, 0x631: 0x0001, 0x632: 0x0001, 0x633: 0x0001, 0x634: 0x0001, 0x635: 0x0001, 0x636: 0x0001, 0x637: 0x0001, 0x638: 0x0001, 0x639: 0x0001, 0x63a: 0x0001, 0x63b: 0x0001, 0x63c: 0x0001, 0x63d: 0x0001, 0x63e: 0x0001, 0x63f: 0x0001, // Block 0x19, offset 0x640 0x640: 0x0001, 0x641: 0x0001, 0x642: 0x0001, 0x643: 0x0001, 0x644: 0x0001, 0x645: 0x0001, 0x646: 0x0001, 0x647: 0x0001, 0x649: 0x0001, 0x64a: 0x0001, 0x64b: 0x0001, 0x64c: 0x0001, 0x64d: 0x0001, 0x64e: 0x0001, 0x64f: 0x0001, 0x650: 0x8000, 0x651: 0x8000, 0x657: 0x0010, 0x658: 0x0010, 0x659: 0x0010, 0x65a: 0x0010, 0x65b: 0x0010, 0x65c: 0x0010, 0x65d: 0x0010, 0x65e: 0x0010, 0x65f: 0x0010, 0x660: 0x0001, 0x661: 0x0001, 0x662: 0x0001, 0x663: 0x0001, 0x664: 0x0001, 0x665: 0x0001, 0x666: 0x0001, 0x667: 0x0001, 0x668: 0x0001, 0x669: 0x0001, 0x66a: 0x0001, 0x66b: 0x0001, 0x66c: 0x0001, 0x66d: 0x0001, 0x66e: 0x0001, 0x66f: 0x0001, 0x670: 0x0001, 0x671: 0x0001, 0x672: 0x0001, 0x673: 0x0001, 0x674: 0x0001, 0x675: 0x0001, 0x676: 0x0001, 0x677: 0x0001, 0x678: 0x0001, 0x679: 0x0001, 0x67a: 0x0001, 0x67b: 0x0001, 0x67c: 0x0001, 0x67d: 0x0001, 0x67e: 0x0001, 0x67f: 0x0001, // Block 0x1a, offset 0x680 0x680: 0x0001, 0x681: 0x0001, 0x682: 0x0001, 0x683: 0x0001, 0x684: 0x0001, 0x685: 0x0001, 0x686: 0x0001, 0x687: 0x0001, 0x688: 0x0001, 0x689: 0x0001, 0x68a: 0x0010, 0x68b: 0x0010, 0x68c: 0x0010, 0x68d: 0x0010, 0x68e: 0x0010, 0x68f: 0x0010, 0x690: 0x0010, 0x691: 0x0010, 0x692: 0x0010, 0x693: 0x0010, 0x694: 0x0010, 0x695: 0x0010, 0x696: 0x0010, 0x697: 0x0010, 0x698: 0x0010, 0x699: 0x0010, 0x69a: 0x0010, 0x69b: 0x0010, 0x69c: 0x0010, 0x69d: 0x0010, 0x69e: 0x0010, 0x69f: 0x0010, 0x6a0: 0x0010, 0x6a1: 0x0010, 0x6a2: 0x8000, 0x6a3: 0x0010, 0x6a4: 0x0010, 0x6a5: 0x0010, 0x6a6: 0x0010, 0x6a7: 0x0010, 0x6a8: 0x0010, 0x6a9: 0x0010, 0x6aa: 0x0010, 0x6ab: 0x0010, 0x6ac: 0x0010, 0x6ad: 0x0010, 0x6ae: 0x0010, 0x6af: 0x0010, 0x6b0: 0x0010, 0x6b1: 0x0010, 0x6b2: 0x0010, 0x6b3: 0x0010, 0x6b4: 0x0010, 0x6b5: 0x0010, 0x6b6: 0x0010, 0x6b7: 0x0010, 0x6b8: 0x0010, 0x6b9: 0x0010, 0x6ba: 0x0010, 0x6bb: 0x0010, 0x6bc: 0x0010, 0x6bd: 0x0010, 0x6be: 0x0010, 0x6bf: 0x0010, // Block 0x1b, offset 0x6c0 0x6c0: 0x0010, 0x6c1: 0x0010, 0x6c2: 0x0010, 0x6c3: 0x0010, 0x6c4: 0x0001, 0x6c5: 0x0001, 0x6c6: 0x0001, 0x6c7: 0x0001, 0x6c8: 0x0001, 0x6c9: 0x0001, 0x6ca: 0x0001, 0x6cb: 0x0001, 0x6cc: 0x0001, 0x6cd: 0x0001, 0x6ce: 0x0001, 0x6cf: 0x0001, 0x6d0: 0x0001, 0x6d1: 0x0001, 0x6d2: 0x0001, 0x6d3: 0x0001, 0x6d4: 0x0001, 0x6d5: 0x0001, 0x6d6: 0x0001, 0x6d7: 0x0001, 0x6d8: 0x0001, 0x6d9: 0x0001, 0x6da: 0x0001, 0x6db: 0x0001, 0x6dc: 0x0001, 0x6dd: 0x0001, 0x6de: 0x0001, 0x6df: 0x0001, 0x6e0: 0x0001, 0x6e1: 0x0001, 0x6e2: 0x0001, 0x6e3: 0x0001, 0x6e4: 0x0001, 0x6e5: 0x0001, 0x6e6: 0x0001, 0x6e7: 0x0001, 0x6e8: 0x0001, 0x6e9: 0x0001, 0x6ea: 0x0001, 0x6eb: 0x0001, 0x6ec: 0x0001, 0x6ed: 0x0001, 0x6ee: 0x0001, 0x6ef: 0x0001, 0x6f0: 0x0001, 0x6f1: 0x0001, 0x6f2: 0x0001, 0x6f3: 0x0001, 0x6f4: 0x0001, 0x6f5: 0x0001, 0x6f6: 0x0001, 0x6f7: 0x0001, 0x6f8: 0x0001, 0x6f9: 0x0001, 0x6fa: 0x0010, 0x6fb: 0x0010, 0x6fc: 0x0010, 0x6fd: 0x0001, 0x6fe: 0x0010, 0x6ff: 0x0010, // Block 0x1c, offset 0x700 0x700: 0x0010, 0x701: 0x0010, 0x702: 0x0010, 0x703: 0x0010, 0x704: 0x0010, 0x705: 0x0010, 0x706: 0x0010, 0x707: 0x0010, 0x708: 0x0010, 0x709: 0x0010, 0x70a: 0x0010, 0x70b: 0x0010, 0x70c: 0x0010, 0x70d: 0x0010, 0x70e: 0x0010, 0x70f: 0x0010, 0x710: 0x0001, 0x711: 0x0010, 0x712: 0x0010, 0x713: 0x0010, 0x714: 0x0010, 0x715: 0x0010, 0x716: 0x0010, 0x717: 0x0010, 0x718: 0x0001, 0x719: 0x0001, 0x71a: 0x0001, 0x71b: 0x0001, 0x71c: 0x0001, 0x71d: 0x0001, 0x71e: 0x0001, 0x71f: 0x0001, 0x720: 0x0001, 0x721: 0x0001, 0x722: 0x0010, 0x723: 0x0010, 0x726: 0x8000, 0x727: 0x8000, 0x728: 0x8000, 0x729: 0x8000, 0x72a: 0x8000, 0x72b: 0x8000, 0x72c: 0x8000, 0x72d: 0x8000, 0x72e: 0x8000, 0x72f: 0x8000, 0x731: 0x0001, 0x732: 0x0001, 0x733: 0x0001, 0x734: 0x0001, 0x735: 0x0001, 0x736: 0x0001, 0x737: 0x0001, 0x738: 0x0001, 0x739: 0x0001, 0x73a: 0x0001, 0x73b: 0x0001, 0x73c: 0x0001, 0x73d: 0x0001, 0x73e: 0x0001, 0x73f: 0x0001, // Block 0x1d, offset 0x740 0x740: 0x0001, 0x741: 0x0010, 0x742: 0x0010, 0x743: 0x0010, 0x745: 0x0001, 0x746: 0x0001, 0x747: 0x0001, 0x748: 0x0001, 0x749: 0x0001, 0x74a: 0x0001, 0x74b: 0x0001, 0x74c: 0x0001, 0x74f: 0x0001, 0x750: 0x0001, 0x753: 0x0001, 0x754: 0x0001, 0x755: 0x0001, 0x756: 0x0001, 0x757: 0x0001, 0x758: 0x0001, 0x759: 0x0001, 0x75a: 0x0001, 0x75b: 0x0001, 0x75c: 0x0001, 0x75d: 0x0001, 0x75e: 0x0001, 0x75f: 0x0001, 0x760: 0x0001, 0x761: 0x0001, 0x762: 0x0001, 0x763: 0x0001, 0x764: 0x0001, 0x765: 0x0001, 0x766: 0x0001, 0x767: 0x0001, 0x768: 0x0001, 0x76a: 0x0001, 0x76b: 0x0001, 0x76c: 0x0001, 0x76d: 0x0001, 0x76e: 0x0001, 0x76f: 0x0001, 0x770: 0x0001, 0x772: 0x0001, 0x776: 0x0001, 0x777: 0x0001, 0x778: 0x0001, 0x779: 0x0001, 0x77c: 0x0010, 0x77d: 0x0001, 0x77e: 0x0010, 0x77f: 0x0010, // Block 0x1e, offset 0x780 0x780: 0x0010, 0x781: 0x0010, 0x782: 0x0010, 0x783: 0x0010, 0x784: 0x0010, 0x787: 0x0010, 0x788: 0x0010, 0x78b: 0x0010, 0x78c: 0x0010, 0x78d: 0x0010, 0x78e: 0x0001, 0x797: 0x0010, 0x79c: 0x0001, 0x79d: 0x0001, 0x79f: 0x0001, 0x7a0: 0x0001, 0x7a1: 0x0001, 0x7a2: 0x0010, 0x7a3: 0x0010, 0x7a6: 0x8000, 0x7a7: 0x8000, 0x7a8: 0x8000, 0x7a9: 0x8000, 0x7aa: 0x8000, 0x7ab: 0x8000, 0x7ac: 0x8000, 0x7ad: 0x8000, 0x7ae: 0x8000, 0x7af: 0x8000, 0x7b0: 0x0001, 0x7b1: 0x0001, 0x7bc: 0x0001, 0x7be: 0x0010, // Block 0x1f, offset 0x7c0 0x7c1: 0x0010, 0x7c2: 0x0010, 0x7c3: 0x0010, 0x7c5: 0x0001, 0x7c6: 0x0001, 0x7c7: 0x0001, 0x7c8: 0x0001, 0x7c9: 0x0001, 0x7ca: 0x0001, 0x7cf: 0x0001, 0x7d0: 0x0001, 0x7d3: 0x0001, 0x7d4: 0x0001, 0x7d5: 0x0001, 0x7d6: 0x0001, 0x7d7: 0x0001, 0x7d8: 0x0001, 0x7d9: 0x0001, 0x7da: 0x0001, 0x7db: 0x0001, 0x7dc: 0x0001, 0x7dd: 0x0001, 0x7de: 0x0001, 0x7df: 0x0001, 0x7e0: 0x0001, 0x7e1: 0x0001, 0x7e2: 0x0001, 0x7e3: 0x0001, 0x7e4: 0x0001, 0x7e5: 0x0001, 0x7e6: 0x0001, 0x7e7: 0x0001, 0x7e8: 0x0001, 0x7ea: 0x0001, 0x7eb: 0x0001, 0x7ec: 0x0001, 0x7ed: 0x0001, 0x7ee: 0x0001, 0x7ef: 0x0001, 0x7f0: 0x0001, 0x7f2: 0x0001, 0x7f3: 0x0001, 0x7f5: 0x0001, 0x7f6: 0x0001, 0x7f8: 0x0001, 0x7f9: 0x0001, 0x7fc: 0x0010, 0x7fe: 0x0010, 0x7ff: 0x0010, // Block 0x20, offset 0x800 0x800: 0x0010, 0x801: 0x0010, 0x802: 0x0010, 0x807: 0x0010, 0x808: 0x0010, 0x80b: 0x0010, 0x80c: 0x0010, 0x80d: 0x0010, 0x811: 0x0010, 0x819: 0x0001, 0x81a: 0x0001, 0x81b: 0x0001, 0x81c: 0x0001, 0x81e: 0x0001, 0x826: 0x8000, 0x827: 0x8000, 0x828: 0x8000, 0x829: 0x8000, 0x82a: 0x8000, 0x82b: 0x8000, 0x82c: 0x8000, 0x82d: 0x8000, 0x82e: 0x8000, 0x82f: 0x8000, 0x830: 0x0010, 0x831: 0x0010, 0x832: 0x0001, 0x833: 0x0001, 0x834: 0x0001, 0x835: 0x0010, // Block 0x21, offset 0x840 0x841: 0x0010, 0x842: 0x0010, 0x843: 0x0010, 0x845: 0x0001, 0x846: 0x0001, 0x847: 0x0001, 0x848: 0x0001, 0x849: 0x0001, 0x84a: 0x0001, 0x84b: 0x0001, 0x84c: 0x0001, 0x84d: 0x0001, 0x84f: 0x0001, 0x850: 0x0001, 0x851: 0x0001, 0x853: 0x0001, 0x854: 0x0001, 0x855: 0x0001, 0x856: 0x0001, 0x857: 0x0001, 0x858: 0x0001, 0x859: 0x0001, 0x85a: 0x0001, 0x85b: 0x0001, 0x85c: 0x0001, 0x85d: 0x0001, 0x85e: 0x0001, 0x85f: 0x0001, 0x860: 0x0001, 0x861: 0x0001, 0x862: 0x0001, 0x863: 0x0001, 0x864: 0x0001, 0x865: 0x0001, 0x866: 0x0001, 0x867: 0x0001, 0x868: 0x0001, 0x86a: 0x0001, 0x86b: 0x0001, 0x86c: 0x0001, 0x86d: 0x0001, 0x86e: 0x0001, 0x86f: 0x0001, 0x870: 0x0001, 0x872: 0x0001, 0x873: 0x0001, 0x875: 0x0001, 0x876: 0x0001, 0x877: 0x0001, 0x878: 0x0001, 0x879: 0x0001, 0x87c: 0x0010, 0x87d: 0x0001, 0x87e: 0x0010, 0x87f: 0x0010, // Block 0x22, offset 0x880 0x880: 0x0010, 0x881: 0x0010, 0x882: 0x0010, 0x883: 0x0010, 0x884: 0x0010, 0x885: 0x0010, 0x887: 0x0010, 0x888: 0x0010, 0x889: 0x0010, 0x88b: 0x0010, 0x88c: 0x0010, 0x88d: 0x0010, 0x890: 0x0001, 0x8a0: 0x0001, 0x8a1: 0x0001, 0x8a2: 0x0010, 0x8a3: 0x0010, 0x8a6: 0x8000, 0x8a7: 0x8000, 0x8a8: 0x8000, 0x8a9: 0x8000, 0x8aa: 0x8000, 0x8ab: 0x8000, 0x8ac: 0x8000, 0x8ad: 0x8000, 0x8ae: 0x8000, 0x8af: 0x8000, 0x8b9: 0x0001, 0x8ba: 0x0010, 0x8bb: 0x0010, 0x8bc: 0x0010, 0x8bd: 0x0010, 0x8be: 0x0010, 0x8bf: 0x0010, // Block 0x23, offset 0x8c0 0x8c1: 0x0010, 0x8c2: 0x0010, 0x8c3: 0x0010, 0x8c5: 0x0001, 0x8c6: 0x0001, 0x8c7: 0x0001, 0x8c8: 0x0001, 0x8c9: 0x0001, 0x8ca: 0x0001, 0x8cb: 0x0001, 0x8cc: 0x0001, 0x8cf: 0x0001, 0x8d0: 0x0001, 0x8d3: 0x0001, 0x8d4: 0x0001, 0x8d5: 0x0001, 0x8d6: 0x0001, 0x8d7: 0x0001, 0x8d8: 0x0001, 0x8d9: 0x0001, 0x8da: 0x0001, 0x8db: 0x0001, 0x8dc: 0x0001, 0x8dd: 0x0001, 0x8de: 0x0001, 0x8df: 0x0001, 0x8e0: 0x0001, 0x8e1: 0x0001, 0x8e2: 0x0001, 0x8e3: 0x0001, 0x8e4: 0x0001, 0x8e5: 0x0001, 0x8e6: 0x0001, 0x8e7: 0x0001, 0x8e8: 0x0001, 0x8ea: 0x0001, 0x8eb: 0x0001, 0x8ec: 0x0001, 0x8ed: 0x0001, 0x8ee: 0x0001, 0x8ef: 0x0001, 0x8f0: 0x0001, 0x8f2: 0x0001, 0x8f3: 0x0001, 0x8f5: 0x0001, 0x8f6: 0x0001, 0x8f7: 0x0001, 0x8f8: 0x0001, 0x8f9: 0x0001, 0x8fc: 0x0010, 0x8fd: 0x0001, 0x8fe: 0x0010, 0x8ff: 0x0010, // Block 0x24, offset 0x900 0x900: 0x0010, 0x901: 0x0010, 0x902: 0x0010, 0x903: 0x0010, 0x904: 0x0010, 0x907: 0x0010, 0x908: 0x0010, 0x90b: 0x0010, 0x90c: 0x0010, 0x90d: 0x0010, 0x915: 0x0010, 0x916: 0x0010, 0x917: 0x0010, 0x91c: 0x0001, 0x91d: 0x0001, 0x91f: 0x0001, 0x920: 0x0001, 0x921: 0x0001, 0x922: 0x0010, 0x923: 0x0010, 0x926: 0x8000, 0x927: 0x8000, 0x928: 0x8000, 0x929: 0x8000, 0x92a: 0x8000, 0x92b: 0x8000, 0x92c: 0x8000, 0x92d: 0x8000, 0x92e: 0x8000, 0x92f: 0x8000, 0x931: 0x0001, // Block 0x25, offset 0x940 0x942: 0x0010, 0x943: 0x0001, 0x945: 0x0001, 0x946: 0x0001, 0x947: 0x0001, 0x948: 0x0001, 0x949: 0x0001, 0x94a: 0x0001, 0x94e: 0x0001, 0x94f: 0x0001, 0x950: 0x0001, 0x952: 0x0001, 0x953: 0x0001, 0x954: 0x0001, 0x955: 0x0001, 0x959: 0x0001, 0x95a: 0x0001, 0x95c: 0x0001, 0x95e: 0x0001, 0x95f: 0x0001, 0x963: 0x0001, 0x964: 0x0001, 0x968: 0x0001, 0x969: 0x0001, 0x96a: 0x0001, 0x96e: 0x0001, 0x96f: 0x0001, 0x970: 0x0001, 0x971: 0x0001, 0x972: 0x0001, 0x973: 0x0001, 0x974: 0x0001, 0x975: 0x0001, 0x976: 0x0001, 0x977: 0x0001, 0x978: 0x0001, 0x979: 0x0001, 0x97e: 0x0010, 0x97f: 0x0010, // Block 0x26, offset 0x980 0x980: 0x0010, 0x981: 0x0010, 0x982: 0x0010, 0x986: 0x0010, 0x987: 0x0010, 0x988: 0x0010, 0x98a: 0x0010, 0x98b: 0x0010, 0x98c: 0x0010, 0x98d: 0x0010, 0x990: 0x0001, 0x997: 0x0010, 0x9a6: 0x8000, 0x9a7: 0x8000, 0x9a8: 0x8000, 0x9a9: 0x8000, 0x9aa: 0x8000, 0x9ab: 0x8000, 0x9ac: 0x8000, 0x9ad: 0x8000, 0x9ae: 0x8000, 0x9af: 0x8000, // Block 0x27, offset 0x9c0 0x9c0: 0x0010, 0x9c1: 0x0010, 0x9c2: 0x0010, 0x9c3: 0x0010, 0x9c4: 0x0010, 0x9c5: 0x0001, 0x9c6: 0x0001, 0x9c7: 0x0001, 0x9c8: 0x0001, 0x9c9: 0x0001, 0x9ca: 0x0001, 0x9cb: 0x0001, 0x9cc: 0x0001, 0x9ce: 0x0001, 0x9cf: 0x0001, 0x9d0: 0x0001, 0x9d2: 0x0001, 0x9d3: 0x0001, 0x9d4: 0x0001, 0x9d5: 0x0001, 0x9d6: 0x0001, 0x9d7: 0x0001, 0x9d8: 0x0001, 0x9d9: 0x0001, 0x9da: 0x0001, 0x9db: 0x0001, 0x9dc: 0x0001, 0x9dd: 0x0001, 0x9de: 0x0001, 0x9df: 0x0001, 0x9e0: 0x0001, 0x9e1: 0x0001, 0x9e2: 0x0001, 0x9e3: 0x0001, 0x9e4: 0x0001, 0x9e5: 0x0001, 0x9e6: 0x0001, 0x9e7: 0x0001, 0x9e8: 0x0001, 0x9ea: 0x0001, 0x9eb: 0x0001, 0x9ec: 0x0001, 0x9ed: 0x0001, 0x9ee: 0x0001, 0x9ef: 0x0001, 0x9f0: 0x0001, 0x9f1: 0x0001, 0x9f2: 0x0001, 0x9f3: 0x0001, 0x9f4: 0x0001, 0x9f5: 0x0001, 0x9f6: 0x0001, 0x9f7: 0x0001, 0x9f8: 0x0001, 0x9f9: 0x0001, 0x9fc: 0x0010, 0x9fd: 0x0001, 0x9fe: 0x0010, 0x9ff: 0x0010, // Block 0x28, offset 0xa00 0xa00: 0x0010, 0xa01: 0x0010, 0xa02: 0x0010, 0xa03: 0x0010, 0xa04: 0x0010, 0xa06: 0x0010, 0xa07: 0x0010, 0xa08: 0x0010, 0xa0a: 0x0010, 0xa0b: 0x0010, 0xa0c: 0x0010, 0xa0d: 0x0010, 0xa15: 0x0010, 0xa16: 0x0010, 0xa18: 0x0001, 0xa19: 0x0001, 0xa1a: 0x0001, 0xa1c: 0x0001, 0xa1d: 0x0001, 0xa20: 0x0001, 0xa21: 0x0001, 0xa22: 0x0010, 0xa23: 0x0010, 0xa26: 0x8000, 0xa27: 0x8000, 0xa28: 0x8000, 0xa29: 0x8000, 0xa2a: 0x8000, 0xa2b: 0x8000, 0xa2c: 0x8000, 0xa2d: 0x8000, 0xa2e: 0x8000, 0xa2f: 0x8000, // Block 0x29, offset 0xa40 0xa40: 0x0001, 0xa41: 0x0010, 0xa42: 0x0010, 0xa43: 0x0010, 0xa45: 0x0001, 0xa46: 0x0001, 0xa47: 0x0001, 0xa48: 0x0001, 0xa49: 0x0001, 0xa4a: 0x0001, 0xa4b: 0x0001, 0xa4c: 0x0001, 0xa4e: 0x0001, 0xa4f: 0x0001, 0xa50: 0x0001, 0xa52: 0x0001, 0xa53: 0x0001, 0xa54: 0x0001, 0xa55: 0x0001, 0xa56: 0x0001, 0xa57: 0x0001, 0xa58: 0x0001, 0xa59: 0x0001, 0xa5a: 0x0001, 0xa5b: 0x0001, 0xa5c: 0x0001, 0xa5d: 0x0001, 0xa5e: 0x0001, 0xa5f: 0x0001, 0xa60: 0x0001, 0xa61: 0x0001, 0xa62: 0x0001, 0xa63: 0x0001, 0xa64: 0x0001, 0xa65: 0x0001, 0xa66: 0x0001, 0xa67: 0x0001, 0xa68: 0x0001, 0xa6a: 0x0001, 0xa6b: 0x0001, 0xa6c: 0x0001, 0xa6d: 0x0001, 0xa6e: 0x0001, 0xa6f: 0x0001, 0xa70: 0x0001, 0xa71: 0x0001, 0xa72: 0x0001, 0xa73: 0x0001, 0xa75: 0x0001, 0xa76: 0x0001, 0xa77: 0x0001, 0xa78: 0x0001, 0xa79: 0x0001, 0xa7c: 0x0010, 0xa7d: 0x0001, 0xa7e: 0x0010, 0xa7f: 0x0010, // Block 0x2a, offset 0xa80 0xa80: 0x0010, 0xa81: 0x0010, 0xa82: 0x0010, 0xa83: 0x0010, 0xa84: 0x0010, 0xa86: 0x0010, 0xa87: 0x0010, 0xa88: 0x0010, 0xa8a: 0x0010, 0xa8b: 0x0010, 0xa8c: 0x0010, 0xa8d: 0x0010, 0xa95: 0x0010, 0xa96: 0x0010, 0xa9c: 0x0001, 0xa9d: 0x0001, 0xa9e: 0x0001, 0xaa0: 0x0001, 0xaa1: 0x0001, 0xaa2: 0x0010, 0xaa3: 0x0010, 0xaa6: 0x8000, 0xaa7: 0x8000, 0xaa8: 0x8000, 0xaa9: 0x8000, 0xaaa: 0x8000, 0xaab: 0x8000, 0xaac: 0x8000, 0xaad: 0x8000, 0xaae: 0x8000, 0xaaf: 0x8000, 0xab1: 0x0001, 0xab2: 0x0001, 0xab3: 0x0010, // Block 0x2b, offset 0xac0 0xac0: 0x0010, 0xac1: 0x0010, 0xac2: 0x0010, 0xac3: 0x0010, 0xac4: 0x0001, 0xac5: 0x0001, 0xac6: 0x0001, 0xac7: 0x0001, 0xac8: 0x0001, 0xac9: 0x0001, 0xaca: 0x0001, 0xacb: 0x0001, 0xacc: 0x0001, 0xace: 0x0001, 0xacf: 0x0001, 0xad0: 0x0001, 0xad2: 0x0001, 0xad3: 0x0001, 0xad4: 0x0001, 0xad5: 0x0001, 0xad6: 0x0001, 0xad7: 0x0001, 0xad8: 0x0001, 0xad9: 0x0001, 0xada: 0x0001, 0xadb: 0x0001, 0xadc: 0x0001, 0xadd: 0x0001, 0xade: 0x0001, 0xadf: 0x0001, 0xae0: 0x0001, 0xae1: 0x0001, 0xae2: 0x0001, 0xae3: 0x0001, 0xae4: 0x0001, 0xae5: 0x0001, 0xae6: 0x0001, 0xae7: 0x0001, 0xae8: 0x0001, 0xae9: 0x0001, 0xaea: 0x0001, 0xaeb: 0x0001, 0xaec: 0x0001, 0xaed: 0x0001, 0xaee: 0x0001, 0xaef: 0x0001, 0xaf0: 0x0001, 0xaf1: 0x0001, 0xaf2: 0x0001, 0xaf3: 0x0001, 0xaf4: 0x0001, 0xaf5: 0x0001, 0xaf6: 0x0001, 0xaf7: 0x0001, 0xaf8: 0x0001, 0xaf9: 0x0001, 0xafa: 0x0001, 0xafb: 0x0010, 0xafc: 0x0010, 0xafd: 0x0001, 0xafe: 0x0010, 0xaff: 0x0010, // Block 0x2c, offset 0xb00 0xb00: 0x0010, 0xb01: 0x0010, 0xb02: 0x0010, 0xb03: 0x0010, 0xb04: 0x0010, 0xb06: 0x0010, 0xb07: 0x0010, 0xb08: 0x0010, 0xb0a: 0x0010, 0xb0b: 0x0010, 0xb0c: 0x0010, 0xb0d: 0x0010, 0xb0e: 0x0001, 0xb14: 0x0001, 0xb15: 0x0001, 0xb16: 0x0001, 0xb17: 0x0010, 0xb1f: 0x0001, 0xb20: 0x0001, 0xb21: 0x0001, 0xb22: 0x0010, 0xb23: 0x0010, 0xb26: 0x8000, 0xb27: 0x8000, 0xb28: 0x8000, 0xb29: 0x8000, 0xb2a: 0x8000, 0xb2b: 0x8000, 0xb2c: 0x8000, 0xb2d: 0x8000, 0xb2e: 0x8000, 0xb2f: 0x8000, 0xb3a: 0x0001, 0xb3b: 0x0001, 0xb3c: 0x0001, 0xb3d: 0x0001, 0xb3e: 0x0001, 0xb3f: 0x0001, // Block 0x2d, offset 0xb40 0xb41: 0x0010, 0xb42: 0x0010, 0xb43: 0x0010, 0xb45: 0x0001, 0xb46: 0x0001, 0xb47: 0x0001, 0xb48: 0x0001, 0xb49: 0x0001, 0xb4a: 0x0001, 0xb4b: 0x0001, 0xb4c: 0x0001, 0xb4d: 0x0001, 0xb4e: 0x0001, 0xb4f: 0x0001, 0xb50: 0x0001, 0xb51: 0x0001, 0xb52: 0x0001, 0xb53: 0x0001, 0xb54: 0x0001, 0xb55: 0x0001, 0xb56: 0x0001, 0xb5a: 0x0001, 0xb5b: 0x0001, 0xb5c: 0x0001, 0xb5d: 0x0001, 0xb5e: 0x0001, 0xb5f: 0x0001, 0xb60: 0x0001, 0xb61: 0x0001, 0xb62: 0x0001, 0xb63: 0x0001, 0xb64: 0x0001, 0xb65: 0x0001, 0xb66: 0x0001, 0xb67: 0x0001, 0xb68: 0x0001, 0xb69: 0x0001, 0xb6a: 0x0001, 0xb6b: 0x0001, 0xb6c: 0x0001, 0xb6d: 0x0001, 0xb6e: 0x0001, 0xb6f: 0x0001, 0xb70: 0x0001, 0xb71: 0x0001, 0xb73: 0x0001, 0xb74: 0x0001, 0xb75: 0x0001, 0xb76: 0x0001, 0xb77: 0x0001, 0xb78: 0x0001, 0xb79: 0x0001, 0xb7a: 0x0001, 0xb7b: 0x0001, 0xb7d: 0x0001, // Block 0x2e, offset 0xb80 0xb80: 0x0001, 0xb81: 0x0001, 0xb82: 0x0001, 0xb83: 0x0001, 0xb84: 0x0001, 0xb85: 0x0001, 0xb86: 0x0001, 0xb8a: 0x0010, 0xb8f: 0x0010, 0xb90: 0x0010, 0xb91: 0x0010, 0xb92: 0x0010, 0xb93: 0x0010, 0xb94: 0x0010, 0xb96: 0x0010, 0xb98: 0x0010, 0xb99: 0x0010, 0xb9a: 0x0010, 0xb9b: 0x0010, 0xb9c: 0x0010, 0xb9d: 0x0010, 0xb9e: 0x0010, 0xb9f: 0x0010, 0xba6: 0x8000, 0xba7: 0x8000, 0xba8: 0x8000, 0xba9: 0x8000, 0xbaa: 0x8000, 0xbab: 0x8000, 0xbac: 0x8000, 0xbad: 0x8000, 0xbae: 0x8000, 0xbaf: 0x8000, 0xbb2: 0x0010, 0xbb3: 0x0010, // Block 0x2f, offset 0xbc0 0xbf1: 0x0010, 0xbf4: 0x0010, 0xbf5: 0x0010, 0xbf6: 0x0010, 0xbf7: 0x0010, 0xbf8: 0x0010, 0xbf9: 0x0010, 0xbfa: 0x0010, // Block 0x30, offset 0xc00 0xc07: 0x0010, 0xc08: 0x0010, 0xc09: 0x0010, 0xc0a: 0x0010, 0xc0b: 0x0010, 0xc0c: 0x0010, 0xc0d: 0x0010, 0xc0e: 0x0010, 0xc10: 0x8000, 0xc11: 0x8000, 0xc12: 0x8000, 0xc13: 0x8000, 0xc14: 0x8000, 0xc15: 0x8000, 0xc16: 0x8000, 0xc17: 0x8000, 0xc18: 0x8000, 0xc19: 0x8000, // Block 0x31, offset 0xc40 0xc71: 0x0010, 0xc74: 0x0010, 0xc75: 0x0010, 0xc76: 0x0010, 0xc77: 0x0010, 0xc78: 0x0010, 0xc79: 0x0010, 0xc7a: 0x0010, 0xc7b: 0x0010, 0xc7c: 0x0010, // Block 0x32, offset 0xc80 0xc88: 0x0010, 0xc89: 0x0010, 0xc8a: 0x0010, 0xc8b: 0x0010, 0xc8c: 0x0010, 0xc8d: 0x0010, 0xc8e: 0x0010, 0xc90: 0x8000, 0xc91: 0x8000, 0xc92: 0x8000, 0xc93: 0x8000, 0xc94: 0x8000, 0xc95: 0x8000, 0xc96: 0x8000, 0xc97: 0x8000, 0xc98: 0x8000, 0xc99: 0x8000, // Block 0x33, offset 0xcc0 0xcc0: 0x0001, 0xcd8: 0x0010, 0xcd9: 0x0010, 0xce0: 0x8000, 0xce1: 0x8000, 0xce2: 0x8000, 0xce3: 0x8000, 0xce4: 0x8000, 0xce5: 0x8000, 0xce6: 0x8000, 0xce7: 0x8000, 0xce8: 0x8000, 0xce9: 0x8000, 0xcf5: 0x0010, 0xcf7: 0x0010, 0xcf9: 0x0010, 0xcfe: 0x0010, 0xcff: 0x0010, // Block 0x34, offset 0xd00 0xd00: 0x0001, 0xd01: 0x0001, 0xd02: 0x0001, 0xd03: 0x0001, 0xd04: 0x0001, 0xd05: 0x0001, 0xd06: 0x0001, 0xd07: 0x0001, 0xd09: 0x0001, 0xd0a: 0x0001, 0xd0b: 0x0001, 0xd0c: 0x0001, 0xd0d: 0x0001, 0xd0e: 0x0001, 0xd0f: 0x0001, 0xd10: 0x0001, 0xd11: 0x0001, 0xd12: 0x0001, 0xd13: 0x0001, 0xd14: 0x0001, 0xd15: 0x0001, 0xd16: 0x0001, 0xd17: 0x0001, 0xd18: 0x0001, 0xd19: 0x0001, 0xd1a: 0x0001, 0xd1b: 0x0001, 0xd1c: 0x0001, 0xd1d: 0x0001, 0xd1e: 0x0001, 0xd1f: 0x0001, 0xd20: 0x0001, 0xd21: 0x0001, 0xd22: 0x0001, 0xd23: 0x0001, 0xd24: 0x0001, 0xd25: 0x0001, 0xd26: 0x0001, 0xd27: 0x0001, 0xd28: 0x0001, 0xd29: 0x0001, 0xd2a: 0x0001, 0xd2b: 0x0001, 0xd2c: 0x0001, 0xd31: 0x0010, 0xd32: 0x0010, 0xd33: 0x0010, 0xd34: 0x0010, 0xd35: 0x0010, 0xd36: 0x0010, 0xd37: 0x0010, 0xd38: 0x0010, 0xd39: 0x0010, 0xd3a: 0x0010, 0xd3b: 0x0010, 0xd3c: 0x0010, 0xd3d: 0x0010, 0xd3e: 0x0010, 0xd3f: 0x0010, // Block 0x35, offset 0xd40 0xd40: 0x0010, 0xd41: 0x0010, 0xd42: 0x0010, 0xd43: 0x0010, 0xd44: 0x0010, 0xd46: 0x0010, 0xd47: 0x0010, 0xd48: 0x0001, 0xd49: 0x0001, 0xd4a: 0x0001, 0xd4b: 0x0001, 0xd4c: 0x0001, 0xd4d: 0x0010, 0xd4e: 0x0010, 0xd4f: 0x0010, 0xd50: 0x0010, 0xd51: 0x0010, 0xd52: 0x0010, 0xd53: 0x0010, 0xd54: 0x0010, 0xd55: 0x0010, 0xd56: 0x0010, 0xd57: 0x0010, 0xd59: 0x0010, 0xd5a: 0x0010, 0xd5b: 0x0010, 0xd5c: 0x0010, 0xd5d: 0x0010, 0xd5e: 0x0010, 0xd5f: 0x0010, 0xd60: 0x0010, 0xd61: 0x0010, 0xd62: 0x0010, 0xd63: 0x0010, 0xd64: 0x0010, 0xd65: 0x0010, 0xd66: 0x0010, 0xd67: 0x0010, 0xd68: 0x0010, 0xd69: 0x0010, 0xd6a: 0x0010, 0xd6b: 0x0010, 0xd6c: 0x0010, 0xd6d: 0x0010, 0xd6e: 0x0010, 0xd6f: 0x0010, 0xd70: 0x0010, 0xd71: 0x0010, 0xd72: 0x0010, 0xd73: 0x0010, 0xd74: 0x0010, 0xd75: 0x0010, 0xd76: 0x0010, 0xd77: 0x0010, 0xd78: 0x0010, 0xd79: 0x0010, 0xd7a: 0x0010, 0xd7b: 0x0010, 0xd7c: 0x0010, // Block 0x36, offset 0xd80 0xd86: 0x0010, // Block 0x37, offset 0xdc0 0xdeb: 0x0010, 0xdec: 0x0010, 0xded: 0x0010, 0xdee: 0x0010, 0xdef: 0x0010, 0xdf0: 0x0010, 0xdf1: 0x0010, 0xdf2: 0x0010, 0xdf3: 0x0010, 0xdf4: 0x0010, 0xdf5: 0x0010, 0xdf6: 0x0010, 0xdf7: 0x0010, 0xdf8: 0x0010, 0xdf9: 0x0010, 0xdfa: 0x0010, 0xdfb: 0x0010, 0xdfc: 0x0010, 0xdfd: 0x0010, 0xdfe: 0x0010, // Block 0x38, offset 0xe00 0xe00: 0x8000, 0xe01: 0x8000, 0xe02: 0x8000, 0xe03: 0x8000, 0xe04: 0x8000, 0xe05: 0x8000, 0xe06: 0x8000, 0xe07: 0x8000, 0xe08: 0x8000, 0xe09: 0x8000, 0xe16: 0x0010, 0xe17: 0x0010, 0xe18: 0x0010, 0xe19: 0x0010, 0xe1e: 0x0010, 0xe1f: 0x0010, 0xe20: 0x0010, 0xe22: 0x0010, 0xe23: 0x0010, 0xe24: 0x0010, 0xe27: 0x0010, 0xe28: 0x0010, 0xe29: 0x0010, 0xe2a: 0x0010, 0xe2b: 0x0010, 0xe2c: 0x0010, 0xe2d: 0x0010, 0xe31: 0x0010, 0xe32: 0x0010, 0xe33: 0x0010, 0xe34: 0x0010, // Block 0x39, offset 0xe40 0xe42: 0x0010, 0xe43: 0x0010, 0xe44: 0x0010, 0xe45: 0x0010, 0xe46: 0x0010, 0xe47: 0x0010, 0xe48: 0x0010, 0xe49: 0x0010, 0xe4a: 0x0010, 0xe4b: 0x0010, 0xe4c: 0x0010, 0xe4d: 0x0010, 0xe4f: 0x0010, 0xe50: 0x8000, 0xe51: 0x8000, 0xe52: 0x8000, 0xe53: 0x8000, 0xe54: 0x8000, 0xe55: 0x8000, 0xe56: 0x8000, 0xe57: 0x8000, 0xe58: 0x8000, 0xe59: 0x8000, 0xe5a: 0x0010, 0xe5b: 0x0010, 0xe5c: 0x0010, 0xe5d: 0x0010, 0xe60: 0x0001, 0xe61: 0x0001, 0xe62: 0x0001, 0xe63: 0x0001, 0xe64: 0x0001, 0xe65: 0x0001, 0xe66: 0x0001, 0xe67: 0x0001, 0xe68: 0x0001, 0xe69: 0x0001, 0xe6a: 0x0001, 0xe6b: 0x0001, 0xe6c: 0x0001, 0xe6d: 0x0001, 0xe6e: 0x0001, 0xe6f: 0x0001, 0xe70: 0x0001, 0xe71: 0x0001, 0xe72: 0x0001, 0xe73: 0x0001, 0xe74: 0x0001, 0xe75: 0x0001, 0xe76: 0x0001, 0xe77: 0x0001, 0xe78: 0x0001, 0xe79: 0x0001, 0xe7a: 0x0001, 0xe7b: 0x0001, 0xe7c: 0x0001, 0xe7d: 0x0001, 0xe7e: 0x0001, 0xe7f: 0x0001, // Block 0x3a, offset 0xe80 0xe80: 0x0001, 0xe81: 0x0001, 0xe82: 0x0001, 0xe83: 0x0001, 0xe84: 0x0001, 0xe85: 0x0001, 0xe87: 0x0001, 0xe8d: 0x0001, 0xe90: 0x0001, 0xe91: 0x0001, 0xe92: 0x0001, 0xe93: 0x0001, 0xe94: 0x0001, 0xe95: 0x0001, 0xe96: 0x0001, 0xe97: 0x0001, 0xe98: 0x0001, 0xe99: 0x0001, 0xe9a: 0x0001, 0xe9b: 0x0001, 0xe9c: 0x0001, 0xe9d: 0x0001, 0xe9e: 0x0001, 0xe9f: 0x0001, 0xea0: 0x0001, 0xea1: 0x0001, 0xea2: 0x0001, 0xea3: 0x0001, 0xea4: 0x0001, 0xea5: 0x0001, 0xea6: 0x0001, 0xea7: 0x0001, 0xea8: 0x0001, 0xea9: 0x0001, 0xeaa: 0x0001, 0xeab: 0x0001, 0xeac: 0x0001, 0xead: 0x0001, 0xeae: 0x0001, 0xeaf: 0x0001, 0xeb0: 0x0001, 0xeb1: 0x0001, 0xeb2: 0x0001, 0xeb3: 0x0001, 0xeb4: 0x0001, 0xeb5: 0x0001, 0xeb6: 0x0001, 0xeb7: 0x0001, 0xeb8: 0x0001, 0xeb9: 0x0001, 0xeba: 0x0001, 0xebc: 0x0001, 0xebd: 0x0001, 0xebe: 0x0001, 0xebf: 0x0001, // Block 0x3b, offset 0xec0 0xec0: 0x0001, 0xec1: 0x0001, 0xec2: 0x0001, 0xec3: 0x0001, 0xec4: 0x0001, 0xec5: 0x0001, 0xec6: 0x0001, 0xec7: 0x0001, 0xec8: 0x0001, 0xeca: 0x0001, 0xecb: 0x0001, 0xecc: 0x0001, 0xecd: 0x0001, 0xed0: 0x0001, 0xed1: 0x0001, 0xed2: 0x0001, 0xed3: 0x0001, 0xed4: 0x0001, 0xed5: 0x0001, 0xed6: 0x0001, 0xed8: 0x0001, 0xeda: 0x0001, 0xedb: 0x0001, 0xedc: 0x0001, 0xedd: 0x0001, 0xee0: 0x0001, 0xee1: 0x0001, 0xee2: 0x0001, 0xee3: 0x0001, 0xee4: 0x0001, 0xee5: 0x0001, 0xee6: 0x0001, 0xee7: 0x0001, 0xee8: 0x0001, 0xee9: 0x0001, 0xeea: 0x0001, 0xeeb: 0x0001, 0xeec: 0x0001, 0xeed: 0x0001, 0xeee: 0x0001, 0xeef: 0x0001, 0xef0: 0x0001, 0xef1: 0x0001, 0xef2: 0x0001, 0xef3: 0x0001, 0xef4: 0x0001, 0xef5: 0x0001, 0xef6: 0x0001, 0xef7: 0x0001, 0xef8: 0x0001, 0xef9: 0x0001, 0xefa: 0x0001, 0xefb: 0x0001, 0xefc: 0x0001, 0xefd: 0x0001, 0xefe: 0x0001, 0xeff: 0x0001, // Block 0x3c, offset 0xf00 0xf00: 0x0001, 0xf01: 0x0001, 0xf02: 0x0001, 0xf03: 0x0001, 0xf04: 0x0001, 0xf05: 0x0001, 0xf06: 0x0001, 0xf07: 0x0001, 0xf08: 0x0001, 0xf0a: 0x0001, 0xf0b: 0x0001, 0xf0c: 0x0001, 0xf0d: 0x0001, 0xf10: 0x0001, 0xf11: 0x0001, 0xf12: 0x0001, 0xf13: 0x0001, 0xf14: 0x0001, 0xf15: 0x0001, 0xf16: 0x0001, 0xf17: 0x0001, 0xf18: 0x0001, 0xf19: 0x0001, 0xf1a: 0x0001, 0xf1b: 0x0001, 0xf1c: 0x0001, 0xf1d: 0x0001, 0xf1e: 0x0001, 0xf1f: 0x0001, 0xf20: 0x0001, 0xf21: 0x0001, 0xf22: 0x0001, 0xf23: 0x0001, 0xf24: 0x0001, 0xf25: 0x0001, 0xf26: 0x0001, 0xf27: 0x0001, 0xf28: 0x0001, 0xf29: 0x0001, 0xf2a: 0x0001, 0xf2b: 0x0001, 0xf2c: 0x0001, 0xf2d: 0x0001, 0xf2e: 0x0001, 0xf2f: 0x0001, 0xf30: 0x0001, 0xf32: 0x0001, 0xf33: 0x0001, 0xf34: 0x0001, 0xf35: 0x0001, 0xf38: 0x0001, 0xf39: 0x0001, 0xf3a: 0x0001, 0xf3b: 0x0001, 0xf3c: 0x0001, 0xf3d: 0x0001, 0xf3e: 0x0001, // Block 0x3d, offset 0xf40 0xf40: 0x0001, 0xf42: 0x0001, 0xf43: 0x0001, 0xf44: 0x0001, 0xf45: 0x0001, 0xf48: 0x0001, 0xf49: 0x0001, 0xf4a: 0x0001, 0xf4b: 0x0001, 0xf4c: 0x0001, 0xf4d: 0x0001, 0xf4e: 0x0001, 0xf4f: 0x0001, 0xf50: 0x0001, 0xf51: 0x0001, 0xf52: 0x0001, 0xf53: 0x0001, 0xf54: 0x0001, 0xf55: 0x0001, 0xf56: 0x0001, 0xf58: 0x0001, 0xf59: 0x0001, 0xf5a: 0x0001, 0xf5b: 0x0001, 0xf5c: 0x0001, 0xf5d: 0x0001, 0xf5e: 0x0001, 0xf5f: 0x0001, 0xf60: 0x0001, 0xf61: 0x0001, 0xf62: 0x0001, 0xf63: 0x0001, 0xf64: 0x0001, 0xf65: 0x0001, 0xf66: 0x0001, 0xf67: 0x0001, 0xf68: 0x0001, 0xf69: 0x0001, 0xf6a: 0x0001, 0xf6b: 0x0001, 0xf6c: 0x0001, 0xf6d: 0x0001, 0xf6e: 0x0001, 0xf6f: 0x0001, 0xf70: 0x0001, 0xf71: 0x0001, 0xf72: 0x0001, 0xf73: 0x0001, 0xf74: 0x0001, 0xf75: 0x0001, 0xf76: 0x0001, 0xf77: 0x0001, 0xf78: 0x0001, 0xf79: 0x0001, 0xf7a: 0x0001, 0xf7b: 0x0001, 0xf7c: 0x0001, 0xf7d: 0x0001, 0xf7e: 0x0001, 0xf7f: 0x0001, // Block 0x3e, offset 0xf80 0xf80: 0x0001, 0xf81: 0x0001, 0xf82: 0x0001, 0xf83: 0x0001, 0xf84: 0x0001, 0xf85: 0x0001, 0xf86: 0x0001, 0xf87: 0x0001, 0xf88: 0x0001, 0xf89: 0x0001, 0xf8a: 0x0001, 0xf8b: 0x0001, 0xf8c: 0x0001, 0xf8d: 0x0001, 0xf8e: 0x0001, 0xf8f: 0x0001, 0xf90: 0x0001, 0xf92: 0x0001, 0xf93: 0x0001, 0xf94: 0x0001, 0xf95: 0x0001, 0xf98: 0x0001, 0xf99: 0x0001, 0xf9a: 0x0001, 0xf9b: 0x0001, 0xf9c: 0x0001, 0xf9d: 0x0001, 0xf9e: 0x0001, 0xf9f: 0x0001, 0xfa0: 0x0001, 0xfa1: 0x0001, 0xfa2: 0x0001, 0xfa3: 0x0001, 0xfa4: 0x0001, 0xfa5: 0x0001, 0xfa6: 0x0001, 0xfa7: 0x0001, 0xfa8: 0x0001, 0xfa9: 0x0001, 0xfaa: 0x0001, 0xfab: 0x0001, 0xfac: 0x0001, 0xfad: 0x0001, 0xfae: 0x0001, 0xfaf: 0x0001, 0xfb0: 0x0001, 0xfb1: 0x0001, 0xfb2: 0x0001, 0xfb3: 0x0001, 0xfb4: 0x0001, 0xfb5: 0x0001, 0xfb6: 0x0001, 0xfb7: 0x0001, 0xfb8: 0x0001, 0xfb9: 0x0001, 0xfba: 0x0001, 0xfbb: 0x0001, 0xfbc: 0x0001, 0xfbd: 0x0001, 0xfbe: 0x0001, 0xfbf: 0x0001, // Block 0x3f, offset 0xfc0 0xfc0: 0x0001, 0xfc1: 0x0001, 0xfc2: 0x0001, 0xfc3: 0x0001, 0xfc4: 0x0001, 0xfc5: 0x0001, 0xfc6: 0x0001, 0xfc7: 0x0001, 0xfc8: 0x0001, 0xfc9: 0x0001, 0xfca: 0x0001, 0xfcb: 0x0001, 0xfcc: 0x0001, 0xfcd: 0x0001, 0xfce: 0x0001, 0xfcf: 0x0001, 0xfd0: 0x0001, 0xfd1: 0x0001, 0xfd2: 0x0001, 0xfd3: 0x0001, 0xfd4: 0x0001, 0xfd5: 0x0001, 0xfd6: 0x0001, 0xfd7: 0x0001, 0xfd8: 0x0001, 0xfd9: 0x0001, 0xfda: 0x0001, 0xfdd: 0x0010, 0xfde: 0x0010, 0xfdf: 0x0010, // Block 0x40, offset 0x1000 0x1000: 0x0001, 0x1001: 0x0001, 0x1002: 0x0001, 0x1003: 0x0001, 0x1004: 0x0001, 0x1005: 0x0001, 0x1006: 0x0001, 0x1007: 0x0001, 0x1008: 0x0001, 0x1009: 0x0001, 0x100a: 0x0001, 0x100b: 0x0001, 0x100c: 0x0001, 0x100d: 0x0001, 0x100e: 0x0001, 0x100f: 0x0001, 0x1020: 0x0001, 0x1021: 0x0001, 0x1022: 0x0001, 0x1023: 0x0001, 0x1024: 0x0001, 0x1025: 0x0001, 0x1026: 0x0001, 0x1027: 0x0001, 0x1028: 0x0001, 0x1029: 0x0001, 0x102a: 0x0001, 0x102b: 0x0001, 0x102c: 0x0001, 0x102d: 0x0001, 0x102e: 0x0001, 0x102f: 0x0001, 0x1030: 0x0001, 0x1031: 0x0001, 0x1032: 0x0001, 0x1033: 0x0001, 0x1034: 0x0001, 0x1035: 0x0001, 0x1036: 0x0001, 0x1037: 0x0001, 0x1038: 0x0001, 0x1039: 0x0001, 0x103a: 0x0001, 0x103b: 0x0001, 0x103c: 0x0001, 0x103d: 0x0001, 0x103e: 0x0001, 0x103f: 0x0001, // Block 0x41, offset 0x1040 0x1040: 0x0001, 0x1041: 0x0001, 0x1042: 0x0001, 0x1043: 0x0001, 0x1044: 0x0001, 0x1045: 0x0001, 0x1046: 0x0001, 0x1047: 0x0001, 0x1048: 0x0001, 0x1049: 0x0001, 0x104a: 0x0001, 0x104b: 0x0001, 0x104c: 0x0001, 0x104d: 0x0001, 0x104e: 0x0001, 0x104f: 0x0001, 0x1050: 0x0001, 0x1051: 0x0001, 0x1052: 0x0001, 0x1053: 0x0001, 0x1054: 0x0001, 0x1055: 0x0001, 0x1056: 0x0001, 0x1057: 0x0001, 0x1058: 0x0001, 0x1059: 0x0001, 0x105a: 0x0001, 0x105b: 0x0001, 0x105c: 0x0001, 0x105d: 0x0001, 0x105e: 0x0001, 0x105f: 0x0001, 0x1060: 0x0001, 0x1061: 0x0001, 0x1062: 0x0001, 0x1063: 0x0001, 0x1064: 0x0001, 0x1065: 0x0001, 0x1066: 0x0001, 0x1067: 0x0001, 0x1068: 0x0001, 0x1069: 0x0001, 0x106a: 0x0001, 0x106b: 0x0001, 0x106c: 0x0001, 0x106d: 0x0001, 0x106e: 0x0001, 0x106f: 0x0001, 0x1070: 0x0001, 0x1071: 0x0001, 0x1072: 0x0001, 0x1073: 0x0001, 0x1074: 0x0001, 0x1075: 0x0001, 0x1078: 0x0001, 0x1079: 0x0001, 0x107a: 0x0001, 0x107b: 0x0001, 0x107c: 0x0001, 0x107d: 0x0001, // Block 0x42, offset 0x1080 0x1081: 0x0001, 0x1082: 0x0001, 0x1083: 0x0001, 0x1084: 0x0001, 0x1085: 0x0001, 0x1086: 0x0001, 0x1087: 0x0001, 0x1088: 0x0001, 0x1089: 0x0001, 0x108a: 0x0001, 0x108b: 0x0001, 0x108c: 0x0001, 0x108d: 0x0001, 0x108e: 0x0001, 0x108f: 0x0001, 0x1090: 0x0001, 0x1091: 0x0001, 0x1092: 0x0001, 0x1093: 0x0001, 0x1094: 0x0001, 0x1095: 0x0001, 0x1096: 0x0001, 0x1097: 0x0001, 0x1098: 0x0001, 0x1099: 0x0001, 0x109a: 0x0001, 0x109b: 0x0001, 0x109c: 0x0001, 0x109d: 0x0001, 0x109e: 0x0001, 0x109f: 0x0001, 0x10a0: 0x0001, 0x10a1: 0x0001, 0x10a2: 0x0001, 0x10a3: 0x0001, 0x10a4: 0x0001, 0x10a5: 0x0001, 0x10a6: 0x0001, 0x10a7: 0x0001, 0x10a8: 0x0001, 0x10a9: 0x0001, 0x10aa: 0x0001, 0x10ab: 0x0001, 0x10ac: 0x0001, 0x10ad: 0x0001, 0x10ae: 0x0001, 0x10af: 0x0001, 0x10b0: 0x0001, 0x10b1: 0x0001, 0x10b2: 0x0001, 0x10b3: 0x0001, 0x10b4: 0x0001, 0x10b5: 0x0001, 0x10b6: 0x0001, 0x10b7: 0x0001, 0x10b8: 0x0001, 0x10b9: 0x0001, 0x10ba: 0x0001, 0x10bb: 0x0001, 0x10bc: 0x0001, 0x10bd: 0x0001, 0x10be: 0x0001, 0x10bf: 0x0001, // Block 0x43, offset 0x10c0 0x10c0: 0x0001, 0x10c1: 0x0001, 0x10c2: 0x0001, 0x10c3: 0x0001, 0x10c4: 0x0001, 0x10c5: 0x0001, 0x10c6: 0x0001, 0x10c7: 0x0001, 0x10c8: 0x0001, 0x10c9: 0x0001, 0x10ca: 0x0001, 0x10cb: 0x0001, 0x10cc: 0x0001, 0x10cd: 0x0001, 0x10ce: 0x0001, 0x10cf: 0x0001, 0x10d0: 0x0001, 0x10d1: 0x0001, 0x10d2: 0x0001, 0x10d3: 0x0001, 0x10d4: 0x0001, 0x10d5: 0x0001, 0x10d6: 0x0001, 0x10d7: 0x0001, 0x10d8: 0x0001, 0x10d9: 0x0001, 0x10da: 0x0001, 0x10db: 0x0001, 0x10dc: 0x0001, 0x10dd: 0x0001, 0x10de: 0x0001, 0x10df: 0x0001, 0x10e0: 0x0001, 0x10e1: 0x0001, 0x10e2: 0x0001, 0x10e3: 0x0001, 0x10e4: 0x0001, 0x10e5: 0x0001, 0x10e6: 0x0001, 0x10e7: 0x0001, 0x10e8: 0x0001, 0x10e9: 0x0001, 0x10ea: 0x0001, 0x10eb: 0x0001, 0x10ec: 0x0001, 0x10ef: 0x0001, 0x10f0: 0x0001, 0x10f1: 0x0001, 0x10f2: 0x0001, 0x10f3: 0x0001, 0x10f4: 0x0001, 0x10f5: 0x0001, 0x10f6: 0x0001, 0x10f7: 0x0001, 0x10f8: 0x0001, 0x10f9: 0x0001, 0x10fa: 0x0001, 0x10fb: 0x0001, 0x10fc: 0x0001, 0x10fd: 0x0001, 0x10fe: 0x0001, 0x10ff: 0x0001, // Block 0x44, offset 0x1100 0x1100: 0x40000, 0x1101: 0x0001, 0x1102: 0x0001, 0x1103: 0x0001, 0x1104: 0x0001, 0x1105: 0x0001, 0x1106: 0x0001, 0x1107: 0x0001, 0x1108: 0x0001, 0x1109: 0x0001, 0x110a: 0x0001, 0x110b: 0x0001, 0x110c: 0x0001, 0x110d: 0x0001, 0x110e: 0x0001, 0x110f: 0x0001, 0x1110: 0x0001, 0x1111: 0x0001, 0x1112: 0x0001, 0x1113: 0x0001, 0x1114: 0x0001, 0x1115: 0x0001, 0x1116: 0x0001, 0x1117: 0x0001, 0x1118: 0x0001, 0x1119: 0x0001, 0x111a: 0x0001, 0x1120: 0x0001, 0x1121: 0x0001, 0x1122: 0x0001, 0x1123: 0x0001, 0x1124: 0x0001, 0x1125: 0x0001, 0x1126: 0x0001, 0x1127: 0x0001, 0x1128: 0x0001, 0x1129: 0x0001, 0x112a: 0x0001, 0x112b: 0x0001, 0x112c: 0x0001, 0x112d: 0x0001, 0x112e: 0x0001, 0x112f: 0x0001, 0x1130: 0x0001, 0x1131: 0x0001, 0x1132: 0x0001, 0x1133: 0x0001, 0x1134: 0x0001, 0x1135: 0x0001, 0x1136: 0x0001, 0x1137: 0x0001, 0x1138: 0x0001, 0x1139: 0x0001, 0x113a: 0x0001, 0x113b: 0x0001, 0x113c: 0x0001, 0x113d: 0x0001, 0x113e: 0x0001, 0x113f: 0x0001, // Block 0x45, offset 0x1140 0x1140: 0x0001, 0x1141: 0x0001, 0x1142: 0x0001, 0x1143: 0x0001, 0x1144: 0x0001, 0x1145: 0x0001, 0x1146: 0x0001, 0x1147: 0x0001, 0x1148: 0x0001, 0x1149: 0x0001, 0x114a: 0x0001, 0x114b: 0x0001, 0x114c: 0x0001, 0x114d: 0x0001, 0x114e: 0x0001, 0x114f: 0x0001, 0x1150: 0x0001, 0x1151: 0x0001, 0x1152: 0x0001, 0x1153: 0x0001, 0x1154: 0x0001, 0x1155: 0x0001, 0x1156: 0x0001, 0x1157: 0x0001, 0x1158: 0x0001, 0x1159: 0x0001, 0x115a: 0x0001, 0x115b: 0x0001, 0x115c: 0x0001, 0x115d: 0x0001, 0x115e: 0x0001, 0x115f: 0x0001, 0x1160: 0x0001, 0x1161: 0x0001, 0x1162: 0x0001, 0x1163: 0x0001, 0x1164: 0x0001, 0x1165: 0x0001, 0x1166: 0x0001, 0x1167: 0x0001, 0x1168: 0x0001, 0x1169: 0x0001, 0x116a: 0x0001, 0x116e: 0x0001, 0x116f: 0x0001, 0x1170: 0x0001, 0x1171: 0x0001, 0x1172: 0x0001, 0x1173: 0x0001, 0x1174: 0x0001, 0x1175: 0x0001, 0x1176: 0x0001, 0x1177: 0x0001, 0x1178: 0x0001, // Block 0x46, offset 0x1180 0x1180: 0x0001, 0x1181: 0x0001, 0x1182: 0x0001, 0x1183: 0x0001, 0x1184: 0x0001, 0x1185: 0x0001, 0x1186: 0x0001, 0x1187: 0x0001, 0x1188: 0x0001, 0x1189: 0x0001, 0x118a: 0x0001, 0x118b: 0x0001, 0x118c: 0x0001, 0x118d: 0x0001, 0x118e: 0x0001, 0x118f: 0x0001, 0x1190: 0x0001, 0x1191: 0x0001, 0x1192: 0x0010, 0x1193: 0x0010, 0x1194: 0x0010, 0x1195: 0x0010, 0x119f: 0x0001, 0x11a0: 0x0001, 0x11a1: 0x0001, 0x11a2: 0x0001, 0x11a3: 0x0001, 0x11a4: 0x0001, 0x11a5: 0x0001, 0x11a6: 0x0001, 0x11a7: 0x0001, 0x11a8: 0x0001, 0x11a9: 0x0001, 0x11aa: 0x0001, 0x11ab: 0x0001, 0x11ac: 0x0001, 0x11ad: 0x0001, 0x11ae: 0x0001, 0x11af: 0x0001, 0x11b0: 0x0001, 0x11b1: 0x0001, 0x11b2: 0x0010, 0x11b3: 0x0010, 0x11b4: 0x0010, // Block 0x47, offset 0x11c0 0x11c0: 0x0001, 0x11c1: 0x0001, 0x11c2: 0x0001, 0x11c3: 0x0001, 0x11c4: 0x0001, 0x11c5: 0x0001, 0x11c6: 0x0001, 0x11c7: 0x0001, 0x11c8: 0x0001, 0x11c9: 0x0001, 0x11ca: 0x0001, 0x11cb: 0x0001, 0x11cc: 0x0001, 0x11cd: 0x0001, 0x11ce: 0x0001, 0x11cf: 0x0001, 0x11d0: 0x0001, 0x11d1: 0x0001, 0x11d2: 0x0010, 0x11d3: 0x0010, 0x11e0: 0x0001, 0x11e1: 0x0001, 0x11e2: 0x0001, 0x11e3: 0x0001, 0x11e4: 0x0001, 0x11e5: 0x0001, 0x11e6: 0x0001, 0x11e7: 0x0001, 0x11e8: 0x0001, 0x11e9: 0x0001, 0x11ea: 0x0001, 0x11eb: 0x0001, 0x11ec: 0x0001, 0x11ee: 0x0001, 0x11ef: 0x0001, 0x11f0: 0x0001, 0x11f2: 0x0010, 0x11f3: 0x0010, // Block 0x48, offset 0x1200 0x1234: 0x0010, 0x1235: 0x0010, 0x1236: 0x0010, 0x1237: 0x0010, 0x1238: 0x0010, 0x1239: 0x0010, 0x123a: 0x0010, 0x123b: 0x0010, 0x123c: 0x0010, 0x123d: 0x0010, 0x123e: 0x0010, 0x123f: 0x0010, // Block 0x49, offset 0x1240 0x1240: 0x0010, 0x1241: 0x0010, 0x1242: 0x0010, 0x1243: 0x0010, 0x1244: 0x0010, 0x1245: 0x0010, 0x1246: 0x0010, 0x1247: 0x0010, 0x1248: 0x0010, 0x1249: 0x0010, 0x124a: 0x0010, 0x124b: 0x0010, 0x124c: 0x0010, 0x124d: 0x0010, 0x124e: 0x0010, 0x124f: 0x0010, 0x1250: 0x0010, 0x1251: 0x0010, 0x1252: 0x0010, 0x1253: 0x0010, 0x125d: 0x0010, 0x1260: 0x8000, 0x1261: 0x8000, 0x1262: 0x8000, 0x1263: 0x8000, 0x1264: 0x8000, 0x1265: 0x8000, 0x1266: 0x8000, 0x1267: 0x8000, 0x1268: 0x8000, 0x1269: 0x8000, // Block 0x4a, offset 0x1280 0x128b: 0x0010, 0x128c: 0x0010, 0x128d: 0x0010, 0x128e: 0x0080, 0x128f: 0x0010, 0x1290: 0x8000, 0x1291: 0x8000, 0x1292: 0x8000, 0x1293: 0x8000, 0x1294: 0x8000, 0x1295: 0x8000, 0x1296: 0x8000, 0x1297: 0x8000, 0x1298: 0x8000, 0x1299: 0x8000, 0x12a0: 0x0001, 0x12a1: 0x0001, 0x12a2: 0x0001, 0x12a3: 0x0001, 0x12a4: 0x0001, 0x12a5: 0x0001, 0x12a6: 0x0001, 0x12a7: 0x0001, 0x12a8: 0x0001, 0x12a9: 0x0001, 0x12aa: 0x0001, 0x12ab: 0x0001, 0x12ac: 0x0001, 0x12ad: 0x0001, 0x12ae: 0x0001, 0x12af: 0x0001, 0x12b0: 0x0001, 0x12b1: 0x0001, 0x12b2: 0x0001, 0x12b3: 0x0001, 0x12b4: 0x0001, 0x12b5: 0x0001, 0x12b6: 0x0001, 0x12b7: 0x0001, 0x12b8: 0x0001, 0x12b9: 0x0001, 0x12ba: 0x0001, 0x12bb: 0x0001, 0x12bc: 0x0001, 0x12bd: 0x0001, 0x12be: 0x0001, 0x12bf: 0x0001, // Block 0x4b, offset 0x12c0 0x12c0: 0x0001, 0x12c1: 0x0001, 0x12c2: 0x0001, 0x12c3: 0x0001, 0x12c4: 0x0001, 0x12c5: 0x0001, 0x12c6: 0x0001, 0x12c7: 0x0001, 0x12c8: 0x0001, 0x12c9: 0x0001, 0x12ca: 0x0001, 0x12cb: 0x0001, 0x12cc: 0x0001, 0x12cd: 0x0001, 0x12ce: 0x0001, 0x12cf: 0x0001, 0x12d0: 0x0001, 0x12d1: 0x0001, 0x12d2: 0x0001, 0x12d3: 0x0001, 0x12d4: 0x0001, 0x12d5: 0x0001, 0x12d6: 0x0001, 0x12d7: 0x0001, 0x12d8: 0x0001, 0x12d9: 0x0001, 0x12da: 0x0001, 0x12db: 0x0001, 0x12dc: 0x0001, 0x12dd: 0x0001, 0x12de: 0x0001, 0x12df: 0x0001, 0x12e0: 0x0001, 0x12e1: 0x0001, 0x12e2: 0x0001, 0x12e3: 0x0001, 0x12e4: 0x0001, 0x12e5: 0x0001, 0x12e6: 0x0001, 0x12e7: 0x0001, 0x12e8: 0x0001, 0x12e9: 0x0001, 0x12ea: 0x0001, 0x12eb: 0x0001, 0x12ec: 0x0001, 0x12ed: 0x0001, 0x12ee: 0x0001, 0x12ef: 0x0001, 0x12f0: 0x0001, 0x12f1: 0x0001, 0x12f2: 0x0001, 0x12f3: 0x0001, 0x12f4: 0x0001, 0x12f5: 0x0001, 0x12f6: 0x0001, 0x12f7: 0x0001, 0x12f8: 0x0001, // Block 0x4c, offset 0x1300 0x1300: 0x0001, 0x1301: 0x0001, 0x1302: 0x0001, 0x1303: 0x0001, 0x1304: 0x0001, 0x1305: 0x0010, 0x1306: 0x0010, 0x1307: 0x0001, 0x1308: 0x0001, 0x1309: 0x0001, 0x130a: 0x0001, 0x130b: 0x0001, 0x130c: 0x0001, 0x130d: 0x0001, 0x130e: 0x0001, 0x130f: 0x0001, 0x1310: 0x0001, 0x1311: 0x0001, 0x1312: 0x0001, 0x1313: 0x0001, 0x1314: 0x0001, 0x1315: 0x0001, 0x1316: 0x0001, 0x1317: 0x0001, 0x1318: 0x0001, 0x1319: 0x0001, 0x131a: 0x0001, 0x131b: 0x0001, 0x131c: 0x0001, 0x131d: 0x0001, 0x131e: 0x0001, 0x131f: 0x0001, 0x1320: 0x0001, 0x1321: 0x0001, 0x1322: 0x0001, 0x1323: 0x0001, 0x1324: 0x0001, 0x1325: 0x0001, 0x1326: 0x0001, 0x1327: 0x0001, 0x1328: 0x0001, 0x1329: 0x0010, 0x132a: 0x0001, 0x1330: 0x0001, 0x1331: 0x0001, 0x1332: 0x0001, 0x1333: 0x0001, 0x1334: 0x0001, 0x1335: 0x0001, 0x1336: 0x0001, 0x1337: 0x0001, 0x1338: 0x0001, 0x1339: 0x0001, 0x133a: 0x0001, 0x133b: 0x0001, 0x133c: 0x0001, 0x133d: 0x0001, 0x133e: 0x0001, 0x133f: 0x0001, // Block 0x4d, offset 0x1340 0x1340: 0x0001, 0x1341: 0x0001, 0x1342: 0x0001, 0x1343: 0x0001, 0x1344: 0x0001, 0x1345: 0x0001, 0x1346: 0x0001, 0x1347: 0x0001, 0x1348: 0x0001, 0x1349: 0x0001, 0x134a: 0x0001, 0x134b: 0x0001, 0x134c: 0x0001, 0x134d: 0x0001, 0x134e: 0x0001, 0x134f: 0x0001, 0x1350: 0x0001, 0x1351: 0x0001, 0x1352: 0x0001, 0x1353: 0x0001, 0x1354: 0x0001, 0x1355: 0x0001, 0x1356: 0x0001, 0x1357: 0x0001, 0x1358: 0x0001, 0x1359: 0x0001, 0x135a: 0x0001, 0x135b: 0x0001, 0x135c: 0x0001, 0x135d: 0x0001, 0x135e: 0x0001, 0x135f: 0x0001, 0x1360: 0x0001, 0x1361: 0x0001, 0x1362: 0x0001, 0x1363: 0x0001, 0x1364: 0x0001, 0x1365: 0x0001, 0x1366: 0x0001, 0x1367: 0x0001, 0x1368: 0x0001, 0x1369: 0x0001, 0x136a: 0x0001, 0x136b: 0x0001, 0x136c: 0x0001, 0x136d: 0x0001, 0x136e: 0x0001, 0x136f: 0x0001, 0x1370: 0x0001, 0x1371: 0x0001, 0x1372: 0x0001, 0x1373: 0x0001, 0x1374: 0x0001, 0x1375: 0x0001, // Block 0x4e, offset 0x1380 0x1380: 0x0001, 0x1381: 0x0001, 0x1382: 0x0001, 0x1383: 0x0001, 0x1384: 0x0001, 0x1385: 0x0001, 0x1386: 0x0001, 0x1387: 0x0001, 0x1388: 0x0001, 0x1389: 0x0001, 0x138a: 0x0001, 0x138b: 0x0001, 0x138c: 0x0001, 0x138d: 0x0001, 0x138e: 0x0001, 0x138f: 0x0001, 0x1390: 0x0001, 0x1391: 0x0001, 0x1392: 0x0001, 0x1393: 0x0001, 0x1394: 0x0001, 0x1395: 0x0001, 0x1396: 0x0001, 0x1397: 0x0001, 0x1398: 0x0001, 0x1399: 0x0001, 0x139a: 0x0001, 0x139b: 0x0001, 0x139c: 0x0001, 0x139d: 0x0001, 0x139e: 0x0001, 0x13a0: 0x0010, 0x13a1: 0x0010, 0x13a2: 0x0010, 0x13a3: 0x0010, 0x13a4: 0x0010, 0x13a5: 0x0010, 0x13a6: 0x0010, 0x13a7: 0x0010, 0x13a8: 0x0010, 0x13a9: 0x0010, 0x13aa: 0x0010, 0x13ab: 0x0010, 0x13b0: 0x0010, 0x13b1: 0x0010, 0x13b2: 0x0010, 0x13b3: 0x0010, 0x13b4: 0x0010, 0x13b5: 0x0010, 0x13b6: 0x0010, 0x13b7: 0x0010, 0x13b8: 0x0010, 0x13b9: 0x0010, 0x13ba: 0x0010, 0x13bb: 0x0010, // Block 0x4f, offset 0x13c0 0x13c6: 0x8000, 0x13c7: 0x8000, 0x13c8: 0x8000, 0x13c9: 0x8000, 0x13ca: 0x8000, 0x13cb: 0x8000, 0x13cc: 0x8000, 0x13cd: 0x8000, 0x13ce: 0x8000, 0x13cf: 0x8000, // Block 0x50, offset 0x1400 0x1410: 0x8000, 0x1411: 0x8000, 0x1412: 0x8000, 0x1413: 0x8000, 0x1414: 0x8000, 0x1415: 0x8000, 0x1416: 0x8000, 0x1417: 0x8000, 0x1418: 0x8000, 0x1419: 0x8000, 0x141a: 0x8000, // Block 0x51, offset 0x1440 0x1440: 0x0001, 0x1441: 0x0001, 0x1442: 0x0001, 0x1443: 0x0001, 0x1444: 0x0001, 0x1445: 0x0001, 0x1446: 0x0001, 0x1447: 0x0001, 0x1448: 0x0001, 0x1449: 0x0001, 0x144a: 0x0001, 0x144b: 0x0001, 0x144c: 0x0001, 0x144d: 0x0001, 0x144e: 0x0001, 0x144f: 0x0001, 0x1450: 0x0001, 0x1451: 0x0001, 0x1452: 0x0001, 0x1453: 0x0001, 0x1454: 0x0001, 0x1455: 0x0001, 0x1456: 0x0001, 0x1457: 0x0010, 0x1458: 0x0010, 0x1459: 0x0010, 0x145a: 0x0010, 0x145b: 0x0010, // Block 0x52, offset 0x1480 0x1495: 0x0010, 0x1496: 0x0010, 0x1497: 0x0010, 0x1498: 0x0010, 0x1499: 0x0010, 0x149a: 0x0010, 0x149b: 0x0010, 0x149c: 0x0010, 0x149d: 0x0010, 0x149e: 0x0010, 0x14a0: 0x0010, 0x14a1: 0x0010, 0x14a2: 0x0010, 0x14a3: 0x0010, 0x14a4: 0x0010, 0x14a5: 0x0010, 0x14a6: 0x0010, 0x14a7: 0x0010, 0x14a8: 0x0010, 0x14a9: 0x0010, 0x14aa: 0x0010, 0x14ab: 0x0010, 0x14ac: 0x0010, 0x14ad: 0x0010, 0x14ae: 0x0010, 0x14af: 0x0010, 0x14b0: 0x0010, 0x14b1: 0x0010, 0x14b2: 0x0010, 0x14b3: 0x0010, 0x14b4: 0x0010, 0x14b5: 0x0010, 0x14b6: 0x0010, 0x14b7: 0x0010, 0x14b8: 0x0010, 0x14b9: 0x0010, 0x14ba: 0x0010, 0x14bb: 0x0010, 0x14bc: 0x0010, 0x14bf: 0x0010, // Block 0x53, offset 0x14c0 0x14c0: 0x8000, 0x14c1: 0x8000, 0x14c2: 0x8000, 0x14c3: 0x8000, 0x14c4: 0x8000, 0x14c5: 0x8000, 0x14c6: 0x8000, 0x14c7: 0x8000, 0x14c8: 0x8000, 0x14c9: 0x8000, 0x14d0: 0x8000, 0x14d1: 0x8000, 0x14d2: 0x8000, 0x14d3: 0x8000, 0x14d4: 0x8000, 0x14d5: 0x8000, 0x14d6: 0x8000, 0x14d7: 0x8000, 0x14d8: 0x8000, 0x14d9: 0x8000, 0x14f0: 0x0010, 0x14f1: 0x0010, 0x14f2: 0x0010, 0x14f3: 0x0010, 0x14f4: 0x0010, 0x14f5: 0x0010, 0x14f6: 0x0010, 0x14f7: 0x0010, 0x14f8: 0x0010, 0x14f9: 0x0010, 0x14fa: 0x0010, 0x14fb: 0x0010, 0x14fc: 0x0010, 0x14fd: 0x0010, 0x14fe: 0x0010, 0x14ff: 0x0010, // Block 0x54, offset 0x1500 0x1500: 0x0010, 0x1501: 0x0010, 0x1502: 0x0010, 0x1503: 0x0010, 0x1504: 0x0010, 0x1505: 0x0010, 0x1506: 0x0010, 0x1507: 0x0010, 0x1508: 0x0010, 0x1509: 0x0010, 0x150a: 0x0010, 0x150b: 0x0010, 0x150c: 0x0010, 0x150d: 0x0010, 0x150e: 0x0010, 0x150f: 0x0010, 0x1510: 0x0010, 0x1511: 0x0010, 0x1512: 0x0010, 0x1513: 0x0010, 0x1514: 0x0010, 0x1515: 0x0010, 0x1516: 0x0010, 0x1517: 0x0010, 0x1518: 0x0010, 0x1519: 0x0010, 0x151a: 0x0010, 0x151b: 0x0010, 0x151c: 0x0010, 0x151d: 0x0010, 0x1520: 0x0010, 0x1521: 0x0010, 0x1522: 0x0010, 0x1523: 0x0010, 0x1524: 0x0010, 0x1525: 0x0010, 0x1526: 0x0010, 0x1527: 0x0010, 0x1528: 0x0010, 0x1529: 0x0010, 0x152a: 0x0010, 0x152b: 0x0010, // Block 0x55, offset 0x1540 0x1540: 0x0010, 0x1541: 0x0010, 0x1542: 0x0010, 0x1543: 0x0010, 0x1544: 0x0010, 0x1545: 0x0001, 0x1546: 0x0001, 0x1547: 0x0001, 0x1548: 0x0001, 0x1549: 0x0001, 0x154a: 0x0001, 0x154b: 0x0001, 0x154c: 0x0001, 0x154d: 0x0001, 0x154e: 0x0001, 0x154f: 0x0001, 0x1550: 0x0001, 0x1551: 0x0001, 0x1552: 0x0001, 0x1553: 0x0001, 0x1554: 0x0001, 0x1555: 0x0001, 0x1556: 0x0001, 0x1557: 0x0001, 0x1558: 0x0001, 0x1559: 0x0001, 0x155a: 0x0001, 0x155b: 0x0001, 0x155c: 0x0001, 0x155d: 0x0001, 0x155e: 0x0001, 0x155f: 0x0001, 0x1560: 0x0001, 0x1561: 0x0001, 0x1562: 0x0001, 0x1563: 0x0001, 0x1564: 0x0001, 0x1565: 0x0001, 0x1566: 0x0001, 0x1567: 0x0001, 0x1568: 0x0001, 0x1569: 0x0001, 0x156a: 0x0001, 0x156b: 0x0001, 0x156c: 0x0001, 0x156d: 0x0001, 0x156e: 0x0001, 0x156f: 0x0001, 0x1570: 0x0001, 0x1571: 0x0001, 0x1572: 0x0001, 0x1573: 0x0001, 0x1574: 0x0010, 0x1575: 0x0010, 0x1576: 0x0010, 0x1577: 0x0010, 0x1578: 0x0010, 0x1579: 0x0010, 0x157a: 0x0010, 0x157b: 0x0010, 0x157c: 0x0010, 0x157d: 0x0010, 0x157e: 0x0010, 0x157f: 0x0010, // Block 0x56, offset 0x1580 0x1580: 0x0010, 0x1581: 0x0010, 0x1582: 0x0010, 0x1583: 0x0010, 0x1584: 0x0010, 0x1585: 0x0001, 0x1586: 0x0001, 0x1587: 0x0001, 0x1588: 0x0001, 0x1589: 0x0001, 0x158a: 0x0001, 0x158b: 0x0001, 0x158c: 0x0001, 0x1590: 0x8000, 0x1591: 0x8000, 0x1592: 0x8000, 0x1593: 0x8000, 0x1594: 0x8000, 0x1595: 0x8000, 0x1596: 0x8000, 0x1597: 0x8000, 0x1598: 0x8000, 0x1599: 0x8000, 0x15ab: 0x0010, 0x15ac: 0x0010, 0x15ad: 0x0010, 0x15ae: 0x0010, 0x15af: 0x0010, 0x15b0: 0x0010, 0x15b1: 0x0010, 0x15b2: 0x0010, 0x15b3: 0x0010, // Block 0x57, offset 0x15c0 0x15c0: 0x0010, 0x15c1: 0x0010, 0x15c2: 0x0010, 0x15c3: 0x0001, 0x15c4: 0x0001, 0x15c5: 0x0001, 0x15c6: 0x0001, 0x15c7: 0x0001, 0x15c8: 0x0001, 0x15c9: 0x0001, 0x15ca: 0x0001, 0x15cb: 0x0001, 0x15cc: 0x0001, 0x15cd: 0x0001, 0x15ce: 0x0001, 0x15cf: 0x0001, 0x15d0: 0x0001, 0x15d1: 0x0001, 0x15d2: 0x0001, 0x15d3: 0x0001, 0x15d4: 0x0001, 0x15d5: 0x0001, 0x15d6: 0x0001, 0x15d7: 0x0001, 0x15d8: 0x0001, 0x15d9: 0x0001, 0x15da: 0x0001, 0x15db: 0x0001, 0x15dc: 0x0001, 0x15dd: 0x0001, 0x15de: 0x0001, 0x15df: 0x0001, 0x15e0: 0x0001, 0x15e1: 0x0010, 0x15e2: 0x0010, 0x15e3: 0x0010, 0x15e4: 0x0010, 0x15e5: 0x0010, 0x15e6: 0x0010, 0x15e7: 0x0010, 0x15e8: 0x0010, 0x15e9: 0x0010, 0x15ea: 0x0010, 0x15eb: 0x0010, 0x15ec: 0x0010, 0x15ed: 0x0010, 0x15ee: 0x0001, 0x15ef: 0x0001, 0x15f0: 0x8000, 0x15f1: 0x8000, 0x15f2: 0x8000, 0x15f3: 0x8000, 0x15f4: 0x8000, 0x15f5: 0x8000, 0x15f6: 0x8000, 0x15f7: 0x8000, 0x15f8: 0x8000, 0x15f9: 0x8000, 0x15fa: 0x0001, 0x15fb: 0x0001, 0x15fc: 0x0001, 0x15fd: 0x0001, 0x15fe: 0x0001, 0x15ff: 0x0001, // Block 0x58, offset 0x1600 0x1600: 0x0001, 0x1601: 0x0001, 0x1602: 0x0001, 0x1603: 0x0001, 0x1604: 0x0001, 0x1605: 0x0001, 0x1606: 0x0001, 0x1607: 0x0001, 0x1608: 0x0001, 0x1609: 0x0001, 0x160a: 0x0001, 0x160b: 0x0001, 0x160c: 0x0001, 0x160d: 0x0001, 0x160e: 0x0001, 0x160f: 0x0001, 0x1610: 0x0001, 0x1611: 0x0001, 0x1612: 0x0001, 0x1613: 0x0001, 0x1614: 0x0001, 0x1615: 0x0001, 0x1616: 0x0001, 0x1617: 0x0001, 0x1618: 0x0001, 0x1619: 0x0001, 0x161a: 0x0001, 0x161b: 0x0001, 0x161c: 0x0001, 0x161d: 0x0001, 0x161e: 0x0001, 0x161f: 0x0001, 0x1620: 0x0001, 0x1621: 0x0001, 0x1622: 0x0001, 0x1623: 0x0001, 0x1624: 0x0001, 0x1625: 0x0001, 0x1626: 0x0010, 0x1627: 0x0010, 0x1628: 0x0010, 0x1629: 0x0010, 0x162a: 0x0010, 0x162b: 0x0010, 0x162c: 0x0010, 0x162d: 0x0010, 0x162e: 0x0010, 0x162f: 0x0010, 0x1630: 0x0010, 0x1631: 0x0010, 0x1632: 0x0010, 0x1633: 0x0010, // Block 0x59, offset 0x1640 0x1640: 0x0001, 0x1641: 0x0001, 0x1642: 0x0001, 0x1643: 0x0001, 0x1644: 0x0001, 0x1645: 0x0001, 0x1646: 0x0001, 0x1647: 0x0001, 0x1648: 0x0001, 0x1649: 0x0001, 0x164a: 0x0001, 0x164b: 0x0001, 0x164c: 0x0001, 0x164d: 0x0001, 0x164e: 0x0001, 0x164f: 0x0001, 0x1650: 0x0001, 0x1651: 0x0001, 0x1652: 0x0001, 0x1653: 0x0001, 0x1654: 0x0001, 0x1655: 0x0001, 0x1656: 0x0001, 0x1657: 0x0001, 0x1658: 0x0001, 0x1659: 0x0001, 0x165a: 0x0001, 0x165b: 0x0001, 0x165c: 0x0001, 0x165d: 0x0001, 0x165e: 0x0001, 0x165f: 0x0001, 0x1660: 0x0001, 0x1661: 0x0001, 0x1662: 0x0001, 0x1663: 0x0001, 0x1664: 0x0010, 0x1665: 0x0010, 0x1666: 0x0010, 0x1667: 0x0010, 0x1668: 0x0010, 0x1669: 0x0010, 0x166a: 0x0010, 0x166b: 0x0010, 0x166c: 0x0010, 0x166d: 0x0010, 0x166e: 0x0010, 0x166f: 0x0010, 0x1670: 0x0010, 0x1671: 0x0010, 0x1672: 0x0010, 0x1673: 0x0010, 0x1674: 0x0010, 0x1675: 0x0010, 0x1676: 0x0010, 0x1677: 0x0010, // Block 0x5a, offset 0x1680 0x1680: 0x8000, 0x1681: 0x8000, 0x1682: 0x8000, 0x1683: 0x8000, 0x1684: 0x8000, 0x1685: 0x8000, 0x1686: 0x8000, 0x1687: 0x8000, 0x1688: 0x8000, 0x1689: 0x8000, 0x168d: 0x0001, 0x168e: 0x0001, 0x168f: 0x0001, 0x1690: 0x8000, 0x1691: 0x8000, 0x1692: 0x8000, 0x1693: 0x8000, 0x1694: 0x8000, 0x1695: 0x8000, 0x1696: 0x8000, 0x1697: 0x8000, 0x1698: 0x8000, 0x1699: 0x8000, 0x169a: 0x0001, 0x169b: 0x0001, 0x169c: 0x0001, 0x169d: 0x0001, 0x169e: 0x0001, 0x169f: 0x0001, 0x16a0: 0x0001, 0x16a1: 0x0001, 0x16a2: 0x0001, 0x16a3: 0x0001, 0x16a4: 0x0001, 0x16a5: 0x0001, 0x16a6: 0x0001, 0x16a7: 0x0001, 0x16a8: 0x0001, 0x16a9: 0x0001, 0x16aa: 0x0001, 0x16ab: 0x0001, 0x16ac: 0x0001, 0x16ad: 0x0001, 0x16ae: 0x0001, 0x16af: 0x0001, 0x16b0: 0x0001, 0x16b1: 0x0001, 0x16b2: 0x0001, 0x16b3: 0x0001, 0x16b4: 0x0001, 0x16b5: 0x0001, 0x16b6: 0x0001, 0x16b7: 0x0001, 0x16b8: 0x0001, 0x16b9: 0x0001, 0x16ba: 0x0001, 0x16bb: 0x0001, 0x16bc: 0x0001, 0x16bd: 0x0001, // Block 0x5b, offset 0x16c0 0x16c0: 0x0001, 0x16c1: 0x0001, 0x16c2: 0x0001, 0x16c3: 0x0001, 0x16c4: 0x0001, 0x16c5: 0x0001, 0x16c6: 0x0001, 0x16c7: 0x0001, 0x16c8: 0x0001, 0x16c9: 0x0001, 0x16ca: 0x0001, 0x16d0: 0x0001, 0x16d1: 0x0001, 0x16d2: 0x0001, 0x16d3: 0x0001, 0x16d4: 0x0001, 0x16d5: 0x0001, 0x16d6: 0x0001, 0x16d7: 0x0001, 0x16d8: 0x0001, 0x16d9: 0x0001, 0x16da: 0x0001, 0x16db: 0x0001, 0x16dc: 0x0001, 0x16dd: 0x0001, 0x16de: 0x0001, 0x16df: 0x0001, 0x16e0: 0x0001, 0x16e1: 0x0001, 0x16e2: 0x0001, 0x16e3: 0x0001, 0x16e4: 0x0001, 0x16e5: 0x0001, 0x16e6: 0x0001, 0x16e7: 0x0001, 0x16e8: 0x0001, 0x16e9: 0x0001, 0x16ea: 0x0001, 0x16eb: 0x0001, 0x16ec: 0x0001, 0x16ed: 0x0001, 0x16ee: 0x0001, 0x16ef: 0x0001, 0x16f0: 0x0001, 0x16f1: 0x0001, 0x16f2: 0x0001, 0x16f3: 0x0001, 0x16f4: 0x0001, 0x16f5: 0x0001, 0x16f6: 0x0001, 0x16f7: 0x0001, 0x16f8: 0x0001, 0x16f9: 0x0001, 0x16fa: 0x0001, 0x16fd: 0x0001, 0x16fe: 0x0001, 0x16ff: 0x0001, // Block 0x5c, offset 0x1700 0x1710: 0x0010, 0x1711: 0x0010, 0x1712: 0x0010, 0x1714: 0x0010, 0x1715: 0x0010, 0x1716: 0x0010, 0x1717: 0x0010, 0x1718: 0x0010, 0x1719: 0x0010, 0x171a: 0x0010, 0x171b: 0x0010, 0x171c: 0x0010, 0x171d: 0x0010, 0x171e: 0x0010, 0x171f: 0x0010, 0x1720: 0x0010, 0x1721: 0x0010, 0x1722: 0x0010, 0x1723: 0x0010, 0x1724: 0x0010, 0x1725: 0x0010, 0x1726: 0x0010, 0x1727: 0x0010, 0x1728: 0x0010, 0x1729: 0x0001, 0x172a: 0x0001, 0x172b: 0x0001, 0x172c: 0x0001, 0x172d: 0x0010, 0x172e: 0x0001, 0x172f: 0x0001, 0x1730: 0x0001, 0x1731: 0x0001, 0x1732: 0x0001, 0x1733: 0x0001, 0x1734: 0x0010, 0x1735: 0x0001, 0x1736: 0x0001, 0x1737: 0x0010, 0x1738: 0x0010, 0x1739: 0x0010, 0x173a: 0x0001, // Block 0x5d, offset 0x1740 0x1740: 0x0001, 0x1741: 0x0001, 0x1742: 0x0001, 0x1743: 0x0001, 0x1744: 0x0001, 0x1745: 0x0001, 0x1746: 0x0001, 0x1747: 0x0001, 0x1748: 0x0001, 0x1749: 0x0001, 0x174a: 0x0001, 0x174b: 0x0001, 0x174c: 0x0001, 0x174d: 0x0001, 0x174e: 0x0001, 0x174f: 0x0001, 0x1750: 0x0001, 0x1751: 0x0001, 0x1752: 0x0001, 0x1753: 0x0001, 0x1754: 0x0001, 0x1755: 0x0001, 0x1758: 0x0001, 0x1759: 0x0001, 0x175a: 0x0001, 0x175b: 0x0001, 0x175c: 0x0001, 0x175d: 0x0001, 0x1760: 0x0001, 0x1761: 0x0001, 0x1762: 0x0001, 0x1763: 0x0001, 0x1764: 0x0001, 0x1765: 0x0001, 0x1766: 0x0001, 0x1767: 0x0001, 0x1768: 0x0001, 0x1769: 0x0001, 0x176a: 0x0001, 0x176b: 0x0001, 0x176c: 0x0001, 0x176d: 0x0001, 0x176e: 0x0001, 0x176f: 0x0001, 0x1770: 0x0001, 0x1771: 0x0001, 0x1772: 0x0001, 0x1773: 0x0001, 0x1774: 0x0001, 0x1775: 0x0001, 0x1776: 0x0001, 0x1777: 0x0001, 0x1778: 0x0001, 0x1779: 0x0001, 0x177a: 0x0001, 0x177b: 0x0001, 0x177c: 0x0001, 0x177d: 0x0001, 0x177e: 0x0001, 0x177f: 0x0001, // Block 0x5e, offset 0x1780 0x1780: 0x0001, 0x1781: 0x0001, 0x1782: 0x0001, 0x1783: 0x0001, 0x1784: 0x0001, 0x1785: 0x0001, 0x1788: 0x0001, 0x1789: 0x0001, 0x178a: 0x0001, 0x178b: 0x0001, 0x178c: 0x0001, 0x178d: 0x0001, 0x1790: 0x0001, 0x1791: 0x0001, 0x1792: 0x0001, 0x1793: 0x0001, 0x1794: 0x0001, 0x1795: 0x0001, 0x1796: 0x0001, 0x1797: 0x0001, 0x1799: 0x0001, 0x179b: 0x0001, 0x179d: 0x0001, 0x179f: 0x0001, 0x17a0: 0x0001, 0x17a1: 0x0001, 0x17a2: 0x0001, 0x17a3: 0x0001, 0x17a4: 0x0001, 0x17a5: 0x0001, 0x17a6: 0x0001, 0x17a7: 0x0001, 0x17a8: 0x0001, 0x17a9: 0x0001, 0x17aa: 0x0001, 0x17ab: 0x0001, 0x17ac: 0x0001, 0x17ad: 0x0001, 0x17ae: 0x0001, 0x17af: 0x0001, 0x17b0: 0x0001, 0x17b1: 0x0001, 0x17b2: 0x0001, 0x17b3: 0x0001, 0x17b4: 0x0001, 0x17b5: 0x0001, 0x17b6: 0x0001, 0x17b7: 0x0001, 0x17b8: 0x0001, 0x17b9: 0x0001, 0x17ba: 0x0001, 0x17bb: 0x0001, 0x17bc: 0x0001, 0x17bd: 0x0001, // Block 0x5f, offset 0x17c0 0x17c0: 0x0001, 0x17c1: 0x0001, 0x17c2: 0x0001, 0x17c3: 0x0001, 0x17c4: 0x0001, 0x17c5: 0x0001, 0x17c6: 0x0001, 0x17c7: 0x0001, 0x17c8: 0x0001, 0x17c9: 0x0001, 0x17ca: 0x0001, 0x17cb: 0x0001, 0x17cc: 0x0001, 0x17cd: 0x0001, 0x17ce: 0x0001, 0x17cf: 0x0001, 0x17d0: 0x0001, 0x17d1: 0x0001, 0x17d2: 0x0001, 0x17d3: 0x0001, 0x17d4: 0x0001, 0x17d5: 0x0001, 0x17d6: 0x0001, 0x17d7: 0x0001, 0x17d8: 0x0001, 0x17d9: 0x0001, 0x17da: 0x0001, 0x17db: 0x0001, 0x17dc: 0x0001, 0x17dd: 0x0001, 0x17de: 0x0001, 0x17df: 0x0001, 0x17e0: 0x0001, 0x17e1: 0x0001, 0x17e2: 0x0001, 0x17e3: 0x0001, 0x17e4: 0x0001, 0x17e5: 0x0001, 0x17e6: 0x0001, 0x17e7: 0x0001, 0x17e8: 0x0001, 0x17e9: 0x0001, 0x17ea: 0x0001, 0x17eb: 0x0001, 0x17ec: 0x0001, 0x17ed: 0x0001, 0x17ee: 0x0001, 0x17ef: 0x0001, 0x17f0: 0x0001, 0x17f1: 0x0001, 0x17f2: 0x0001, 0x17f3: 0x0001, 0x17f4: 0x0001, 0x17f6: 0x0001, 0x17f7: 0x0001, 0x17f8: 0x0001, 0x17f9: 0x0001, 0x17fa: 0x0001, 0x17fb: 0x0001, 0x17fc: 0x0001, 0x17fe: 0x0001, // Block 0x60, offset 0x1800 0x1802: 0x0001, 0x1803: 0x0001, 0x1804: 0x0001, 0x1806: 0x0001, 0x1807: 0x0001, 0x1808: 0x0001, 0x1809: 0x0001, 0x180a: 0x0001, 0x180b: 0x0001, 0x180c: 0x0001, 0x1810: 0x0001, 0x1811: 0x0001, 0x1812: 0x0001, 0x1813: 0x0001, 0x1816: 0x0001, 0x1817: 0x0001, 0x1818: 0x0001, 0x1819: 0x0001, 0x181a: 0x0001, 0x181b: 0x0001, 0x1820: 0x0001, 0x1821: 0x0001, 0x1822: 0x0001, 0x1823: 0x0001, 0x1824: 0x0001, 0x1825: 0x0001, 0x1826: 0x0001, 0x1827: 0x0001, 0x1828: 0x0001, 0x1829: 0x0001, 0x182a: 0x0001, 0x182b: 0x0001, 0x182c: 0x0001, 0x1832: 0x0001, 0x1833: 0x0001, 0x1834: 0x0001, 0x1836: 0x0001, 0x1837: 0x0001, 0x1838: 0x0001, 0x1839: 0x0001, 0x183a: 0x0001, 0x183b: 0x0001, 0x183c: 0x0001, // Block 0x61, offset 0x1840 0x1840: 0x40000, 0x1841: 0x40000, 0x1842: 0x40000, 0x1843: 0x40000, 0x1844: 0x40000, 0x1845: 0x40000, 0x1846: 0x40000, 0x1848: 0x40000, 0x1849: 0x40000, 0x184a: 0x40000, 0x184c: 0x0010, 0x184d: 0x80000, 0x184e: 0x0080, 0x184f: 0x0080, 0x1858: 0x2000, 0x1859: 0x2000, 0x1864: 0x2000, 0x1867: 0x0800, 0x1868: 0x4000, 0x1869: 0x4000, 0x186a: 0x0080, 0x186b: 0x0080, 0x186c: 0x0080, 0x186d: 0x0080, 0x186e: 0x0080, 0x186f: 0x0020, 0x187c: 0x0040, 0x187f: 0x0020, // Block 0x62, offset 0x1880 0x1880: 0x0020, 0x1884: 0x1000, 0x1889: 0x0040, 0x1894: 0x0020, 0x189f: 0x40000, 0x18a0: 0x0080, 0x18a1: 0x0080, 0x18a2: 0x0080, 0x18a3: 0x0080, 0x18a4: 0x0080, 0x18a6: 0x0080, 0x18a7: 0x0080, 0x18a8: 0x0080, 0x18a9: 0x0080, 0x18aa: 0x0080, 0x18ab: 0x0080, 0x18ac: 0x0080, 0x18ad: 0x0080, 0x18ae: 0x0080, 0x18af: 0x0080, 0x18b1: 0x0001, 0x18bf: 0x0001, // Block 0x63, offset 0x18c0 0x18d0: 0x0001, 0x18d1: 0x0001, 0x18d2: 0x0001, 0x18d3: 0x0001, 0x18d4: 0x0001, 0x18d5: 0x0001, 0x18d6: 0x0001, 0x18d7: 0x0001, 0x18d8: 0x0001, 0x18d9: 0x0001, 0x18da: 0x0001, 0x18db: 0x0001, 0x18dc: 0x0001, // Block 0x64, offset 0x1900 0x1910: 0x0010, 0x1911: 0x0010, 0x1912: 0x0010, 0x1913: 0x0010, 0x1914: 0x0010, 0x1915: 0x0010, 0x1916: 0x0010, 0x1917: 0x0010, 0x1918: 0x0010, 0x1919: 0x0010, 0x191a: 0x0010, 0x191b: 0x0010, 0x191c: 0x0010, 0x191d: 0x0010, 0x191e: 0x0010, 0x191f: 0x0010, 0x1920: 0x0010, 0x1921: 0x0010, 0x1922: 0x0010, 0x1923: 0x0010, 0x1924: 0x0010, 0x1925: 0x0010, 0x1926: 0x0010, 0x1927: 0x0010, 0x1928: 0x0010, 0x1929: 0x0010, 0x192a: 0x0010, 0x192b: 0x0010, 0x192c: 0x0010, 0x192d: 0x0010, 0x192e: 0x0010, 0x192f: 0x0010, 0x1930: 0x0010, // Block 0x65, offset 0x1940 0x1942: 0x0001, 0x1947: 0x0001, 0x194a: 0x0001, 0x194b: 0x0001, 0x194c: 0x0001, 0x194d: 0x0001, 0x194e: 0x0001, 0x194f: 0x0001, 0x1950: 0x0001, 0x1951: 0x0001, 0x1952: 0x0001, 0x1953: 0x0001, 0x1955: 0x0001, 0x1959: 0x0001, 0x195a: 0x0001, 0x195b: 0x0001, 0x195c: 0x0001, 0x195d: 0x0001, 0x1962: 0x0040, 0x1964: 0x0001, 0x1966: 0x0001, 0x1968: 0x0001, 0x196a: 0x0001, 0x196b: 0x0001, 0x196c: 0x0001, 0x196d: 0x0001, 0x196f: 0x0001, 0x1970: 0x0001, 0x1971: 0x0001, 0x1972: 0x0001, 0x1973: 0x0001, 0x1974: 0x0001, 0x1975: 0x0001, 0x1976: 0x0001, 0x1977: 0x0001, 0x1978: 0x0001, 0x1979: 0x0041, 0x197c: 0x0001, 0x197d: 0x0001, 0x197e: 0x0001, 0x197f: 0x0001, // Block 0x66, offset 0x1980 0x1985: 0x0001, 0x1986: 0x0001, 0x1987: 0x0001, 0x1988: 0x0001, 0x1989: 0x0001, 0x198e: 0x0001, 0x19a0: 0x0001, 0x19a1: 0x0001, 0x19a2: 0x0001, 0x19a3: 0x0001, 0x19a4: 0x0001, 0x19a5: 0x0001, 0x19a6: 0x0001, 0x19a7: 0x0001, 0x19a8: 0x0001, 0x19a9: 0x0001, 0x19aa: 0x0001, 0x19ab: 0x0001, 0x19ac: 0x0001, 0x19ad: 0x0001, 0x19ae: 0x0001, 0x19af: 0x0001, 0x19b0: 0x0001, 0x19b1: 0x0001, 0x19b2: 0x0001, 0x19b3: 0x0001, 0x19b4: 0x0001, 0x19b5: 0x0001, 0x19b6: 0x0001, 0x19b7: 0x0001, 0x19b8: 0x0001, 0x19b9: 0x0001, 0x19ba: 0x0001, 0x19bb: 0x0001, 0x19bc: 0x0001, 0x19bd: 0x0001, 0x19be: 0x0001, 0x19bf: 0x0001, // Block 0x67, offset 0x19c0 0x19c0: 0x0001, 0x19c1: 0x0001, 0x19c2: 0x0001, 0x19c3: 0x0001, 0x19c4: 0x0001, 0x19c5: 0x0001, 0x19c6: 0x0001, 0x19c7: 0x0001, 0x19c8: 0x0001, 0x19d4: 0x0040, 0x19d5: 0x0040, 0x19d6: 0x0040, 0x19d7: 0x0040, 0x19d8: 0x0040, 0x19d9: 0x0040, 0x19e9: 0x0040, 0x19ea: 0x0040, // Block 0x68, offset 0x1a00 0x1a1a: 0x0040, 0x1a1b: 0x0040, 0x1a28: 0x0040, // Block 0x69, offset 0x1a40 0x1a4f: 0x0040, 0x1a69: 0x0040, 0x1a6a: 0x0040, 0x1a6b: 0x0040, 0x1a6c: 0x0040, 0x1a6d: 0x0040, 0x1a6e: 0x0040, 0x1a6f: 0x0040, 0x1a70: 0x0040, 0x1a71: 0x0040, 0x1a72: 0x0040, 0x1a73: 0x0040, 0x1a78: 0x0040, 0x1a79: 0x0040, 0x1a7a: 0x0040, // Block 0x6a, offset 0x1a80 0x1ab6: 0x0001, 0x1ab7: 0x0001, 0x1ab8: 0x0001, 0x1ab9: 0x0001, 0x1aba: 0x0001, 0x1abb: 0x0001, 0x1abc: 0x0001, 0x1abd: 0x0001, 0x1abe: 0x0001, 0x1abf: 0x0001, // Block 0x6b, offset 0x1ac0 0x1ac0: 0x0001, 0x1ac1: 0x0001, 0x1ac2: 0x0041, 0x1ac3: 0x0001, 0x1ac4: 0x0001, 0x1ac5: 0x0001, 0x1ac6: 0x0001, 0x1ac7: 0x0001, 0x1ac8: 0x0001, 0x1ac9: 0x0001, 0x1aca: 0x0001, 0x1acb: 0x0001, 0x1acc: 0x0001, 0x1acd: 0x0001, 0x1ace: 0x0001, 0x1acf: 0x0001, 0x1ad0: 0x0001, 0x1ad1: 0x0001, 0x1ad2: 0x0001, 0x1ad3: 0x0001, 0x1ad4: 0x0001, 0x1ad5: 0x0001, 0x1ad6: 0x0001, 0x1ad7: 0x0001, 0x1ad8: 0x0001, 0x1ad9: 0x0001, 0x1ada: 0x0001, 0x1adb: 0x0001, 0x1adc: 0x0001, 0x1add: 0x0001, 0x1ade: 0x0001, 0x1adf: 0x0001, 0x1ae0: 0x0001, 0x1ae1: 0x0001, 0x1ae2: 0x0001, 0x1ae3: 0x0001, 0x1ae4: 0x0001, 0x1ae5: 0x0001, 0x1ae6: 0x0001, 0x1ae7: 0x0001, 0x1ae8: 0x0001, 0x1ae9: 0x0001, // Block 0x6c, offset 0x1b00 0x1b2a: 0x0040, 0x1b2b: 0x0040, 0x1b36: 0x0040, // Block 0x6d, offset 0x1b40 0x1b40: 0x0040, 0x1b7b: 0x0040, 0x1b7c: 0x0040, 0x1b7d: 0x0040, 0x1b7e: 0x0040, // Block 0x6e, offset 0x1b80 0x1b80: 0x0040, 0x1b81: 0x0040, 0x1b82: 0x0040, 0x1b83: 0x0040, 0x1b84: 0x0040, 0x1b8e: 0x0040, 0x1b91: 0x0040, 0x1b94: 0x0040, 0x1b95: 0x0040, 0x1b98: 0x0040, 0x1b9d: 0x0040, 0x1ba0: 0x0040, 0x1ba2: 0x0040, 0x1ba3: 0x0040, 0x1ba6: 0x0040, 0x1baa: 0x0040, 0x1bae: 0x0040, 0x1baf: 0x0040, 0x1bb8: 0x0040, 0x1bb9: 0x0040, 0x1bba: 0x0040, // Block 0x6f, offset 0x1bc0 0x1bc0: 0x0040, 0x1bc2: 0x0040, 0x1bc8: 0x0040, 0x1bc9: 0x0040, 0x1bca: 0x0040, 0x1bcb: 0x0040, 0x1bcc: 0x0040, 0x1bcd: 0x0040, 0x1bce: 0x0040, 0x1bcf: 0x0040, 0x1bd0: 0x0040, 0x1bd1: 0x0040, 0x1bd2: 0x0040, 0x1bd3: 0x0040, 0x1bdf: 0x0040, 0x1be0: 0x0040, 0x1be3: 0x0040, 0x1be5: 0x0040, 0x1be6: 0x0040, 0x1be8: 0x0040, 0x1bfb: 0x0040, 0x1bfe: 0x0040, 0x1bff: 0x0040, // Block 0x70, offset 0x1c00 0x1c12: 0x0040, 0x1c13: 0x0040, 0x1c14: 0x0040, 0x1c15: 0x0040, 0x1c16: 0x0040, 0x1c17: 0x0040, 0x1c19: 0x0040, 0x1c1b: 0x0040, 0x1c1c: 0x0040, 0x1c20: 0x0040, 0x1c21: 0x0040, 0x1c27: 0x0040, 0x1c2a: 0x0040, 0x1c2b: 0x0040, 0x1c30: 0x0040, 0x1c31: 0x0040, 0x1c3d: 0x0040, 0x1c3e: 0x0040, // Block 0x71, offset 0x1c40 0x1c44: 0x0040, 0x1c45: 0x0040, 0x1c48: 0x0040, 0x1c4e: 0x0040, 0x1c4f: 0x0040, 0x1c51: 0x0040, 0x1c53: 0x0040, 0x1c54: 0x0040, 0x1c69: 0x0040, 0x1c6a: 0x0040, 0x1c70: 0x0040, 0x1c71: 0x0040, 0x1c72: 0x0040, 0x1c73: 0x0040, 0x1c74: 0x0040, 0x1c75: 0x0040, 0x1c77: 0x0040, 0x1c78: 0x0040, 0x1c79: 0x0040, 0x1c7a: 0x0040, 0x1c7d: 0x0040, // Block 0x72, offset 0x1c80 0x1c82: 0x0040, 0x1c85: 0x0040, 0x1c88: 0x0040, 0x1c89: 0x0040, 0x1c8a: 0x0040, 0x1c8b: 0x0040, 0x1c8c: 0x0040, 0x1c8d: 0x0040, 0x1c8f: 0x0040, 0x1c92: 0x0040, 0x1c94: 0x0040, 0x1c96: 0x0040, 0x1c9d: 0x0040, 0x1ca1: 0x0040, 0x1ca8: 0x0040, 0x1cb3: 0x0040, 0x1cb4: 0x0040, // Block 0x73, offset 0x1cc0 0x1cc4: 0x0040, 0x1cc7: 0x0040, 0x1ccc: 0x0040, 0x1cce: 0x0040, 0x1cd3: 0x0040, 0x1cd4: 0x0040, 0x1cd5: 0x0040, 0x1cd7: 0x0040, 0x1ce3: 0x0040, 0x1ce4: 0x0040, // Block 0x74, offset 0x1d00 0x1d15: 0x0040, 0x1d16: 0x0040, 0x1d17: 0x0040, 0x1d21: 0x0040, 0x1d30: 0x0040, 0x1d3f: 0x0040, // Block 0x75, offset 0x1d40 0x1d74: 0x0040, 0x1d75: 0x0040, // Block 0x76, offset 0x1d80 0x1d85: 0x0040, 0x1d86: 0x0040, 0x1d87: 0x0040, 0x1d9b: 0x0040, 0x1d9c: 0x0040, // Block 0x77, offset 0x1dc0 0x1dd0: 0x0040, 0x1dd5: 0x0040, // Block 0x78, offset 0x1e00 0x1e00: 0x0001, 0x1e01: 0x0001, 0x1e02: 0x0001, 0x1e03: 0x0001, 0x1e04: 0x0001, 0x1e05: 0x0001, 0x1e06: 0x0001, 0x1e07: 0x0001, 0x1e08: 0x0001, 0x1e09: 0x0001, 0x1e0a: 0x0001, 0x1e0b: 0x0001, 0x1e0c: 0x0001, 0x1e0d: 0x0001, 0x1e0e: 0x0001, 0x1e0f: 0x0001, 0x1e10: 0x0001, 0x1e11: 0x0001, 0x1e12: 0x0001, 0x1e13: 0x0001, 0x1e14: 0x0001, 0x1e15: 0x0001, 0x1e16: 0x0001, 0x1e17: 0x0001, 0x1e18: 0x0001, 0x1e19: 0x0001, 0x1e1a: 0x0001, 0x1e1b: 0x0001, 0x1e1c: 0x0001, 0x1e1d: 0x0001, 0x1e1e: 0x0001, 0x1e1f: 0x0001, 0x1e20: 0x0001, 0x1e21: 0x0001, 0x1e22: 0x0001, 0x1e23: 0x0001, 0x1e24: 0x0001, 0x1e2b: 0x0001, 0x1e2c: 0x0001, 0x1e2d: 0x0001, 0x1e2e: 0x0001, 0x1e2f: 0x0010, 0x1e30: 0x0010, 0x1e31: 0x0010, 0x1e32: 0x0001, 0x1e33: 0x0001, // Block 0x79, offset 0x1e40 0x1e40: 0x0001, 0x1e41: 0x0001, 0x1e42: 0x0001, 0x1e43: 0x0001, 0x1e44: 0x0001, 0x1e45: 0x0001, 0x1e46: 0x0001, 0x1e47: 0x0001, 0x1e48: 0x0001, 0x1e49: 0x0001, 0x1e4a: 0x0001, 0x1e4b: 0x0001, 0x1e4c: 0x0001, 0x1e4d: 0x0001, 0x1e4e: 0x0001, 0x1e4f: 0x0001, 0x1e50: 0x0001, 0x1e51: 0x0001, 0x1e52: 0x0001, 0x1e53: 0x0001, 0x1e54: 0x0001, 0x1e55: 0x0001, 0x1e56: 0x0001, 0x1e57: 0x0001, 0x1e58: 0x0001, 0x1e59: 0x0001, 0x1e5a: 0x0001, 0x1e5b: 0x0001, 0x1e5c: 0x0001, 0x1e5d: 0x0001, 0x1e5e: 0x0001, 0x1e5f: 0x0001, 0x1e60: 0x0001, 0x1e61: 0x0001, 0x1e62: 0x0001, 0x1e63: 0x0001, 0x1e64: 0x0001, 0x1e65: 0x0001, 0x1e67: 0x0001, 0x1e6d: 0x0001, 0x1e70: 0x0001, 0x1e71: 0x0001, 0x1e72: 0x0001, 0x1e73: 0x0001, 0x1e74: 0x0001, 0x1e75: 0x0001, 0x1e76: 0x0001, 0x1e77: 0x0001, 0x1e78: 0x0001, 0x1e79: 0x0001, 0x1e7a: 0x0001, 0x1e7b: 0x0001, 0x1e7c: 0x0001, 0x1e7d: 0x0001, 0x1e7e: 0x0001, 0x1e7f: 0x0001, // Block 0x7a, offset 0x1e80 0x1e80: 0x0001, 0x1e81: 0x0001, 0x1e82: 0x0001, 0x1e83: 0x0001, 0x1e84: 0x0001, 0x1e85: 0x0001, 0x1e86: 0x0001, 0x1e87: 0x0001, 0x1e88: 0x0001, 0x1e89: 0x0001, 0x1e8a: 0x0001, 0x1e8b: 0x0001, 0x1e8c: 0x0001, 0x1e8d: 0x0001, 0x1e8e: 0x0001, 0x1e8f: 0x0001, 0x1e90: 0x0001, 0x1e91: 0x0001, 0x1e92: 0x0001, 0x1e93: 0x0001, 0x1e94: 0x0001, 0x1e95: 0x0001, 0x1e96: 0x0001, 0x1e97: 0x0001, 0x1e98: 0x0001, 0x1e99: 0x0001, 0x1e9a: 0x0001, 0x1e9b: 0x0001, 0x1e9c: 0x0001, 0x1e9d: 0x0001, 0x1e9e: 0x0001, 0x1e9f: 0x0001, 0x1ea0: 0x0001, 0x1ea1: 0x0001, 0x1ea2: 0x0001, 0x1ea3: 0x0001, 0x1ea4: 0x0001, 0x1ea5: 0x0001, 0x1ea6: 0x0001, 0x1ea7: 0x0001, 0x1eaf: 0x0001, 0x1ebf: 0x0010, // Block 0x7b, offset 0x1ec0 0x1ec0: 0x0001, 0x1ec1: 0x0001, 0x1ec2: 0x0001, 0x1ec3: 0x0001, 0x1ec4: 0x0001, 0x1ec5: 0x0001, 0x1ec6: 0x0001, 0x1ec7: 0x0001, 0x1ec8: 0x0001, 0x1ec9: 0x0001, 0x1eca: 0x0001, 0x1ecb: 0x0001, 0x1ecc: 0x0001, 0x1ecd: 0x0001, 0x1ece: 0x0001, 0x1ecf: 0x0001, 0x1ed0: 0x0001, 0x1ed1: 0x0001, 0x1ed2: 0x0001, 0x1ed3: 0x0001, 0x1ed4: 0x0001, 0x1ed5: 0x0001, 0x1ed6: 0x0001, 0x1ee0: 0x0001, 0x1ee1: 0x0001, 0x1ee2: 0x0001, 0x1ee3: 0x0001, 0x1ee4: 0x0001, 0x1ee5: 0x0001, 0x1ee6: 0x0001, 0x1ee8: 0x0001, 0x1ee9: 0x0001, 0x1eea: 0x0001, 0x1eeb: 0x0001, 0x1eec: 0x0001, 0x1eed: 0x0001, 0x1eee: 0x0001, 0x1ef0: 0x0001, 0x1ef1: 0x0001, 0x1ef2: 0x0001, 0x1ef3: 0x0001, 0x1ef4: 0x0001, 0x1ef5: 0x0001, 0x1ef6: 0x0001, 0x1ef8: 0x0001, 0x1ef9: 0x0001, 0x1efa: 0x0001, 0x1efb: 0x0001, 0x1efc: 0x0001, 0x1efd: 0x0001, 0x1efe: 0x0001, // Block 0x7c, offset 0x1f00 0x1f00: 0x0001, 0x1f01: 0x0001, 0x1f02: 0x0001, 0x1f03: 0x0001, 0x1f04: 0x0001, 0x1f05: 0x0001, 0x1f06: 0x0001, 0x1f08: 0x0001, 0x1f09: 0x0001, 0x1f0a: 0x0001, 0x1f0b: 0x0001, 0x1f0c: 0x0001, 0x1f0d: 0x0001, 0x1f0e: 0x0001, 0x1f10: 0x0001, 0x1f11: 0x0001, 0x1f12: 0x0001, 0x1f13: 0x0001, 0x1f14: 0x0001, 0x1f15: 0x0001, 0x1f16: 0x0001, 0x1f18: 0x0001, 0x1f19: 0x0001, 0x1f1a: 0x0001, 0x1f1b: 0x0001, 0x1f1c: 0x0001, 0x1f1d: 0x0001, 0x1f1e: 0x0001, 0x1f20: 0x0010, 0x1f21: 0x0010, 0x1f22: 0x0010, 0x1f23: 0x0010, 0x1f24: 0x0010, 0x1f25: 0x0010, 0x1f26: 0x0010, 0x1f27: 0x0010, 0x1f28: 0x0010, 0x1f29: 0x0010, 0x1f2a: 0x0010, 0x1f2b: 0x0010, 0x1f2c: 0x0010, 0x1f2d: 0x0010, 0x1f2e: 0x0010, 0x1f2f: 0x0010, 0x1f30: 0x0010, 0x1f31: 0x0010, 0x1f32: 0x0010, 0x1f33: 0x0010, 0x1f34: 0x0010, 0x1f35: 0x0010, 0x1f36: 0x0010, 0x1f37: 0x0010, 0x1f38: 0x0010, 0x1f39: 0x0010, 0x1f3a: 0x0010, 0x1f3b: 0x0010, 0x1f3c: 0x0010, 0x1f3d: 0x0010, 0x1f3e: 0x0010, 0x1f3f: 0x0010, // Block 0x7d, offset 0x1f40 0x1f6f: 0x0001, // Block 0x7e, offset 0x1f80 0x1f80: 0x0002, 0x1f81: 0x0002, 0x1f82: 0x0002, 0x1f83: 0x0002, 0x1f84: 0x0002, 0x1f85: 0x0002, 0x1f86: 0x0002, 0x1f87: 0x0002, 0x1f88: 0x0002, 0x1f89: 0x0002, 0x1f8a: 0x0002, 0x1f8b: 0x0002, 0x1f8c: 0x0002, 0x1f8d: 0x0002, 0x1f8e: 0x0002, 0x1f8f: 0x0002, 0x1f90: 0x0002, 0x1f91: 0x0002, 0x1f92: 0x0002, 0x1f93: 0x0002, 0x1f94: 0x0002, 0x1f95: 0x0002, 0x1f96: 0x0002, 0x1f97: 0x0002, 0x1f98: 0x0002, 0x1f99: 0x0002, 0x1f9b: 0x0002, 0x1f9c: 0x0002, 0x1f9d: 0x0002, 0x1f9e: 0x0002, 0x1f9f: 0x0002, 0x1fa0: 0x0002, 0x1fa1: 0x0002, 0x1fa2: 0x0002, 0x1fa3: 0x0002, 0x1fa4: 0x0002, 0x1fa5: 0x0002, 0x1fa6: 0x0002, 0x1fa7: 0x0002, 0x1fa8: 0x0002, 0x1fa9: 0x0002, 0x1faa: 0x0002, 0x1fab: 0x0002, 0x1fac: 0x0002, 0x1fad: 0x0002, 0x1fae: 0x0002, 0x1faf: 0x0002, 0x1fb0: 0x0002, 0x1fb1: 0x0002, 0x1fb2: 0x0002, 0x1fb3: 0x0002, 0x1fb4: 0x0002, 0x1fb5: 0x0002, 0x1fb6: 0x0002, 0x1fb7: 0x0002, 0x1fb8: 0x0002, 0x1fb9: 0x0002, 0x1fba: 0x0002, 0x1fbb: 0x0002, 0x1fbc: 0x0002, 0x1fbd: 0x0002, 0x1fbe: 0x0002, 0x1fbf: 0x0002, // Block 0x7f, offset 0x1fc0 0x1fc0: 0x0002, 0x1fc1: 0x0002, 0x1fc2: 0x0002, 0x1fc3: 0x0002, 0x1fc4: 0x0002, 0x1fc5: 0x0002, 0x1fc6: 0x0002, 0x1fc7: 0x0002, 0x1fc8: 0x0002, 0x1fc9: 0x0002, 0x1fca: 0x0002, 0x1fcb: 0x0002, 0x1fcc: 0x0002, 0x1fcd: 0x0002, 0x1fce: 0x0002, 0x1fcf: 0x0002, 0x1fd0: 0x0002, 0x1fd1: 0x0002, 0x1fd2: 0x0002, 0x1fd3: 0x0002, 0x1fd4: 0x0002, 0x1fd5: 0x0002, 0x1fd6: 0x0002, 0x1fd7: 0x0002, 0x1fd8: 0x0002, 0x1fd9: 0x0002, 0x1fda: 0x0002, 0x1fdb: 0x0002, 0x1fdc: 0x0002, 0x1fdd: 0x0002, 0x1fde: 0x0002, 0x1fdf: 0x0002, 0x1fe0: 0x0002, 0x1fe1: 0x0002, 0x1fe2: 0x0002, 0x1fe3: 0x0002, 0x1fe4: 0x0002, 0x1fe5: 0x0002, 0x1fe6: 0x0002, 0x1fe7: 0x0002, 0x1fe8: 0x0002, 0x1fe9: 0x0002, 0x1fea: 0x0002, 0x1feb: 0x0002, 0x1fec: 0x0002, 0x1fed: 0x0002, 0x1fee: 0x0002, 0x1fef: 0x0002, 0x1ff0: 0x0002, 0x1ff1: 0x0002, 0x1ff2: 0x0002, 0x1ff3: 0x0002, // Block 0x80, offset 0x2000 0x2000: 0x0002, 0x2001: 0x0002, 0x2002: 0x0002, 0x2003: 0x0002, 0x2004: 0x0002, 0x2005: 0x0002, 0x2006: 0x0002, 0x2007: 0x0002, 0x2008: 0x0002, 0x2009: 0x0002, 0x200a: 0x0002, 0x200b: 0x0002, 0x200c: 0x0002, 0x200d: 0x0002, 0x200e: 0x0002, 0x200f: 0x0002, 0x2010: 0x0002, 0x2011: 0x0002, 0x2012: 0x0002, 0x2013: 0x0002, 0x2014: 0x0002, 0x2015: 0x0002, 0x2016: 0x0002, 0x2017: 0x0002, 0x2018: 0x0002, 0x2019: 0x0002, 0x201a: 0x0002, 0x201b: 0x0002, 0x201c: 0x0002, 0x201d: 0x0002, 0x201e: 0x0002, 0x201f: 0x0002, 0x2020: 0x0002, 0x2021: 0x0002, 0x2022: 0x0002, 0x2023: 0x0002, 0x2024: 0x0002, 0x2025: 0x0002, 0x2026: 0x0002, 0x2027: 0x0002, 0x2028: 0x0002, 0x2029: 0x0002, 0x202a: 0x0002, 0x202b: 0x0002, 0x202c: 0x0002, 0x202d: 0x0002, 0x202e: 0x0002, 0x202f: 0x0002, 0x2030: 0x0002, 0x2031: 0x0002, 0x2032: 0x0002, 0x2033: 0x0002, 0x2034: 0x0002, 0x2035: 0x0002, 0x2036: 0x0002, 0x2037: 0x0002, 0x2038: 0x0002, 0x2039: 0x0002, 0x203a: 0x0002, 0x203b: 0x0002, 0x203c: 0x0002, 0x203d: 0x0002, 0x203e: 0x0002, 0x203f: 0x0002, // Block 0x81, offset 0x2040 0x2040: 0x0002, 0x2041: 0x0002, 0x2042: 0x0002, 0x2043: 0x0002, 0x2044: 0x0002, 0x2045: 0x0002, 0x2046: 0x0002, 0x2047: 0x0002, 0x2048: 0x0002, 0x2049: 0x0002, 0x204a: 0x0002, 0x204b: 0x0002, 0x204c: 0x0002, 0x204d: 0x0002, 0x204e: 0x0002, 0x204f: 0x0002, 0x2050: 0x0002, 0x2051: 0x0002, 0x2052: 0x0002, 0x2053: 0x0002, 0x2054: 0x0002, 0x2055: 0x0002, // Block 0x82, offset 0x2080 0x2080: 0x40000, 0x2085: 0x0003, 0x2087: 0x0002, 0x20a1: 0x0002, 0x20a2: 0x0002, 0x20a3: 0x0002, 0x20a4: 0x0002, 0x20a5: 0x0002, 0x20a6: 0x0002, 0x20a7: 0x0002, 0x20a8: 0x0002, 0x20a9: 0x0002, 0x20aa: 0x0010, 0x20ab: 0x0010, 0x20ac: 0x0010, 0x20ad: 0x0010, 0x20ae: 0x0010, 0x20af: 0x0010, 0x20b0: 0x0040, 0x20b1: 0x0202, 0x20b2: 0x0202, 0x20b3: 0x0202, 0x20b4: 0x0202, 0x20b5: 0x0202, 0x20b8: 0x0002, 0x20b9: 0x0002, 0x20ba: 0x0002, 0x20bb: 0x0003, 0x20bc: 0x0001, 0x20bd: 0x0040, // Block 0x83, offset 0x20c0 0x20c1: 0x0002, 0x20c2: 0x0002, 0x20c3: 0x0002, 0x20c4: 0x0002, 0x20c5: 0x0002, 0x20c6: 0x0002, 0x20c7: 0x0002, 0x20c8: 0x0002, 0x20c9: 0x0002, 0x20ca: 0x0002, 0x20cb: 0x0002, 0x20cc: 0x0002, 0x20cd: 0x0002, 0x20ce: 0x0002, 0x20cf: 0x0002, 0x20d0: 0x0002, 0x20d1: 0x0002, 0x20d2: 0x0002, 0x20d3: 0x0002, 0x20d4: 0x0002, 0x20d5: 0x0002, 0x20d6: 0x0002, 0x20d7: 0x0002, 0x20d8: 0x0002, 0x20d9: 0x0002, 0x20da: 0x0002, 0x20db: 0x0002, 0x20dc: 0x0002, 0x20dd: 0x0002, 0x20de: 0x0002, 0x20df: 0x0002, 0x20e0: 0x0002, 0x20e1: 0x0002, 0x20e2: 0x0002, 0x20e3: 0x0002, 0x20e4: 0x0002, 0x20e5: 0x0002, 0x20e6: 0x0002, 0x20e7: 0x0002, 0x20e8: 0x0002, 0x20e9: 0x0002, 0x20ea: 0x0002, 0x20eb: 0x0002, 0x20ec: 0x0002, 0x20ed: 0x0002, 0x20ee: 0x0002, 0x20ef: 0x0002, 0x20f0: 0x0002, 0x20f1: 0x0002, 0x20f2: 0x0002, 0x20f3: 0x0002, 0x20f4: 0x0002, 0x20f5: 0x0002, 0x20f6: 0x0002, 0x20f7: 0x0002, 0x20f8: 0x0002, 0x20f9: 0x0002, 0x20fa: 0x0002, 0x20fb: 0x0002, 0x20fc: 0x0002, 0x20fd: 0x0002, 0x20fe: 0x0002, 0x20ff: 0x0002, // Block 0x84, offset 0x2100 0x2100: 0x0002, 0x2101: 0x0002, 0x2102: 0x0002, 0x2103: 0x0002, 0x2104: 0x0002, 0x2105: 0x0002, 0x2106: 0x0002, 0x2107: 0x0002, 0x2108: 0x0002, 0x2109: 0x0002, 0x210a: 0x0002, 0x210b: 0x0002, 0x210c: 0x0002, 0x210d: 0x0002, 0x210e: 0x0002, 0x210f: 0x0002, 0x2110: 0x0002, 0x2111: 0x0002, 0x2112: 0x0002, 0x2113: 0x0002, 0x2114: 0x0002, 0x2115: 0x0002, 0x2116: 0x0002, 0x2119: 0x0010, 0x211a: 0x0010, 0x211b: 0x0202, 0x211c: 0x0202, 0x211d: 0x0002, 0x211e: 0x0002, 0x211f: 0x0002, 0x2120: 0x0202, 0x2121: 0x0202, 0x2122: 0x0202, 0x2123: 0x0202, 0x2124: 0x0202, 0x2125: 0x0202, 0x2126: 0x0202, 0x2127: 0x0202, 0x2128: 0x0202, 0x2129: 0x0202, 0x212a: 0x0202, 0x212b: 0x0202, 0x212c: 0x0202, 0x212d: 0x0202, 0x212e: 0x0202, 0x212f: 0x0202, 0x2130: 0x0202, 0x2131: 0x0202, 0x2132: 0x0202, 0x2133: 0x0202, 0x2134: 0x0202, 0x2135: 0x0202, 0x2136: 0x0202, 0x2137: 0x0202, 0x2138: 0x0202, 0x2139: 0x0202, 0x213a: 0x0202, 0x213b: 0x0202, 0x213c: 0x0202, 0x213d: 0x0202, 0x213e: 0x0202, 0x213f: 0x0202, // Block 0x85, offset 0x2140 0x2140: 0x0202, 0x2141: 0x0202, 0x2142: 0x0202, 0x2143: 0x0202, 0x2144: 0x0202, 0x2145: 0x0202, 0x2146: 0x0202, 0x2147: 0x0202, 0x2148: 0x0202, 0x2149: 0x0202, 0x214a: 0x0202, 0x214b: 0x0202, 0x214c: 0x0202, 0x214d: 0x0202, 0x214e: 0x0202, 0x214f: 0x0202, 0x2150: 0x0202, 0x2151: 0x0202, 0x2152: 0x0202, 0x2153: 0x0202, 0x2154: 0x0202, 0x2155: 0x0202, 0x2156: 0x0202, 0x2157: 0x0202, 0x2158: 0x0202, 0x2159: 0x0202, 0x215a: 0x0202, 0x215b: 0x0202, 0x215c: 0x0202, 0x215d: 0x0202, 0x215e: 0x0202, 0x215f: 0x0202, 0x2160: 0x0202, 0x2161: 0x0202, 0x2162: 0x0202, 0x2163: 0x0202, 0x2164: 0x0202, 0x2165: 0x0202, 0x2166: 0x0202, 0x2167: 0x0202, 0x2168: 0x0202, 0x2169: 0x0202, 0x216a: 0x0202, 0x216b: 0x0202, 0x216c: 0x0202, 0x216d: 0x0202, 0x216e: 0x0202, 0x216f: 0x0202, 0x2170: 0x0202, 0x2171: 0x0202, 0x2172: 0x0202, 0x2173: 0x0202, 0x2174: 0x0202, 0x2175: 0x0202, 0x2176: 0x0202, 0x2177: 0x0202, 0x2178: 0x0202, 0x2179: 0x0202, 0x217a: 0x0202, 0x217c: 0x0202, 0x217d: 0x0202, 0x217e: 0x0202, 0x217f: 0x0202, // Block 0x86, offset 0x2180 0x2185: 0x0001, 0x2186: 0x0001, 0x2187: 0x0001, 0x2188: 0x0001, 0x2189: 0x0001, 0x218a: 0x0001, 0x218b: 0x0001, 0x218c: 0x0001, 0x218d: 0x0001, 0x218e: 0x0001, 0x218f: 0x0001, 0x2190: 0x0001, 0x2191: 0x0001, 0x2192: 0x0001, 0x2193: 0x0001, 0x2194: 0x0001, 0x2195: 0x0001, 0x2196: 0x0001, 0x2197: 0x0001, 0x2198: 0x0001, 0x2199: 0x0001, 0x219a: 0x0001, 0x219b: 0x0001, 0x219c: 0x0001, 0x219d: 0x0001, 0x219e: 0x0001, 0x219f: 0x0001, 0x21a0: 0x0001, 0x21a1: 0x0001, 0x21a2: 0x0001, 0x21a3: 0x0001, 0x21a4: 0x0001, 0x21a5: 0x0001, 0x21a6: 0x0001, 0x21a7: 0x0001, 0x21a8: 0x0001, 0x21a9: 0x0001, 0x21aa: 0x0001, 0x21ab: 0x0001, 0x21ac: 0x0001, 0x21ad: 0x0001, 0x21ae: 0x0001, 0x21af: 0x0001, 0x21b1: 0x0001, 0x21b2: 0x0001, 0x21b3: 0x0001, 0x21b4: 0x0001, 0x21b5: 0x0001, 0x21b6: 0x0001, 0x21b7: 0x0001, 0x21b8: 0x0001, 0x21b9: 0x0001, 0x21ba: 0x0001, 0x21bb: 0x0001, 0x21bc: 0x0001, 0x21bd: 0x0001, 0x21be: 0x0001, 0x21bf: 0x0001, // Block 0x87, offset 0x21c0 0x21c0: 0x0001, 0x21c1: 0x0001, 0x21c2: 0x0001, 0x21c3: 0x0001, 0x21c4: 0x0001, 0x21c5: 0x0001, 0x21c6: 0x0001, 0x21c7: 0x0001, 0x21c8: 0x0001, 0x21c9: 0x0001, 0x21ca: 0x0001, 0x21cb: 0x0001, 0x21cc: 0x0001, 0x21cd: 0x0001, 0x21ce: 0x0001, 0x21e0: 0x0001, 0x21e1: 0x0001, 0x21e2: 0x0001, 0x21e3: 0x0001, 0x21e4: 0x0001, 0x21e5: 0x0001, 0x21e6: 0x0001, 0x21e7: 0x0001, 0x21e8: 0x0001, 0x21e9: 0x0001, 0x21ea: 0x0001, 0x21eb: 0x0001, 0x21ec: 0x0001, 0x21ed: 0x0001, 0x21ee: 0x0001, 0x21ef: 0x0001, 0x21f0: 0x0001, 0x21f1: 0x0001, 0x21f2: 0x0001, 0x21f3: 0x0001, 0x21f4: 0x0001, 0x21f5: 0x0001, 0x21f6: 0x0001, 0x21f7: 0x0001, 0x21f8: 0x0001, 0x21f9: 0x0001, 0x21fa: 0x0001, 0x21fb: 0x0001, 0x21fc: 0x0001, 0x21fd: 0x0001, 0x21fe: 0x0001, 0x21ff: 0x0001, // Block 0x88, offset 0x2200 0x2230: 0x0202, 0x2231: 0x0202, 0x2232: 0x0202, 0x2233: 0x0202, 0x2234: 0x0202, 0x2235: 0x0202, 0x2236: 0x0202, 0x2237: 0x0202, 0x2238: 0x0202, 0x2239: 0x0202, 0x223a: 0x0202, 0x223b: 0x0202, 0x223c: 0x0202, 0x223d: 0x0202, 0x223e: 0x0202, 0x223f: 0x0202, // Block 0x89, offset 0x2240 0x2257: 0x0040, 0x2259: 0x0040, // Block 0x8a, offset 0x2280 0x2290: 0x0202, 0x2291: 0x0202, 0x2292: 0x0202, 0x2293: 0x0202, 0x2294: 0x0202, 0x2295: 0x0202, 0x2296: 0x0202, 0x2297: 0x0202, 0x2298: 0x0202, 0x2299: 0x0202, 0x229a: 0x0202, 0x229b: 0x0202, 0x229c: 0x0202, 0x229d: 0x0202, 0x229e: 0x0202, 0x229f: 0x0202, 0x22a0: 0x0202, 0x22a1: 0x0202, 0x22a2: 0x0202, 0x22a3: 0x0202, 0x22a4: 0x0202, 0x22a5: 0x0202, 0x22a6: 0x0202, 0x22a7: 0x0202, 0x22a8: 0x0202, 0x22a9: 0x0202, 0x22aa: 0x0202, 0x22ab: 0x0202, 0x22ac: 0x0202, 0x22ad: 0x0202, 0x22ae: 0x0202, 0x22af: 0x0202, 0x22b0: 0x0202, 0x22b1: 0x0202, 0x22b2: 0x0202, 0x22b3: 0x0202, 0x22b4: 0x0202, 0x22b5: 0x0202, 0x22b6: 0x0202, 0x22b7: 0x0202, 0x22b8: 0x0202, 0x22b9: 0x0202, 0x22ba: 0x0202, 0x22bb: 0x0202, 0x22bc: 0x0202, 0x22bd: 0x0202, 0x22be: 0x0202, // Block 0x8b, offset 0x22c0 0x22c0: 0x0202, 0x22c1: 0x0202, 0x22c2: 0x0202, 0x22c3: 0x0202, 0x22c4: 0x0202, 0x22c5: 0x0202, 0x22c6: 0x0202, 0x22c7: 0x0202, 0x22c8: 0x0202, 0x22c9: 0x0202, 0x22ca: 0x0202, 0x22cb: 0x0202, 0x22cc: 0x0202, 0x22cd: 0x0202, 0x22ce: 0x0202, 0x22cf: 0x0202, 0x22d0: 0x0202, 0x22d1: 0x0202, 0x22d2: 0x0202, 0x22d3: 0x0202, 0x22d4: 0x0202, 0x22d5: 0x0202, 0x22d6: 0x0202, 0x22d7: 0x0202, 0x22d8: 0x0202, 0x22d9: 0x0202, 0x22da: 0x0202, 0x22db: 0x0202, 0x22dc: 0x0202, 0x22dd: 0x0202, 0x22de: 0x0202, 0x22df: 0x0202, 0x22e0: 0x0202, 0x22e1: 0x0202, 0x22e2: 0x0202, 0x22e3: 0x0202, 0x22e4: 0x0202, 0x22e5: 0x0202, 0x22e6: 0x0202, 0x22e7: 0x0202, 0x22e8: 0x0202, 0x22e9: 0x0202, 0x22ea: 0x0202, 0x22eb: 0x0202, 0x22ec: 0x0202, 0x22ed: 0x0202, 0x22ee: 0x0202, 0x22ef: 0x0202, 0x22f0: 0x0202, 0x22f1: 0x0202, 0x22f2: 0x0202, 0x22f3: 0x0202, 0x22f4: 0x0202, 0x22f5: 0x0202, 0x22f6: 0x0202, 0x22f7: 0x0202, 0x22f8: 0x0202, 0x22f9: 0x0202, 0x22fa: 0x0202, 0x22fb: 0x0202, 0x22fc: 0x0202, 0x22fd: 0x0202, 0x22fe: 0x0202, 0x22ff: 0x0202, // Block 0x8c, offset 0x2300 0x2300: 0x0202, 0x2301: 0x0202, 0x2302: 0x0202, 0x2303: 0x0202, 0x2304: 0x0202, 0x2305: 0x0202, 0x2306: 0x0202, 0x2307: 0x0202, 0x2308: 0x0202, 0x2309: 0x0202, 0x230a: 0x0202, 0x230b: 0x0202, 0x230c: 0x0202, 0x230d: 0x0202, 0x230e: 0x0202, 0x230f: 0x0202, 0x2310: 0x0202, 0x2311: 0x0202, 0x2312: 0x0202, 0x2313: 0x0202, 0x2314: 0x0202, 0x2315: 0x0202, 0x2316: 0x0202, 0x2317: 0x0202, // Block 0x8d, offset 0x2340 0x2340: 0x0001, 0x2341: 0x0001, 0x2342: 0x0001, 0x2343: 0x0001, 0x2344: 0x0001, 0x2345: 0x0001, 0x2346: 0x0001, 0x2347: 0x0001, 0x2348: 0x0001, 0x2349: 0x0001, 0x234a: 0x0001, 0x234b: 0x0001, 0x234c: 0x0001, // Block 0x8e, offset 0x2380 0x2390: 0x0001, 0x2391: 0x0001, 0x2392: 0x0001, 0x2393: 0x0001, 0x2394: 0x0001, 0x2395: 0x0001, 0x2396: 0x0001, 0x2397: 0x0001, 0x2398: 0x0001, 0x2399: 0x0001, 0x239a: 0x0001, 0x239b: 0x0001, 0x239c: 0x0001, 0x239d: 0x0001, 0x239e: 0x0001, 0x239f: 0x0001, 0x23a0: 0x0001, 0x23a1: 0x0001, 0x23a2: 0x0001, 0x23a3: 0x0001, 0x23a4: 0x0001, 0x23a5: 0x0001, 0x23a6: 0x0001, 0x23a7: 0x0001, 0x23a8: 0x0001, 0x23a9: 0x0001, 0x23aa: 0x0001, 0x23ab: 0x0001, 0x23ac: 0x0001, 0x23ad: 0x0001, 0x23ae: 0x0001, 0x23af: 0x0001, 0x23b0: 0x0001, 0x23b1: 0x0001, 0x23b2: 0x0001, 0x23b3: 0x0001, 0x23b4: 0x0001, 0x23b5: 0x0001, 0x23b6: 0x0001, 0x23b7: 0x0001, 0x23b8: 0x0001, 0x23b9: 0x0001, 0x23ba: 0x0001, 0x23bb: 0x0001, 0x23bc: 0x0001, 0x23bd: 0x0001, // Block 0x8f, offset 0x23c0 0x23c0: 0x0001, 0x23c1: 0x0001, 0x23c2: 0x0001, 0x23c3: 0x0001, 0x23c4: 0x0001, 0x23c5: 0x0001, 0x23c6: 0x0001, 0x23c7: 0x0001, 0x23c8: 0x0001, 0x23c9: 0x0001, 0x23ca: 0x0001, 0x23cb: 0x0001, 0x23cc: 0x0001, 0x23d0: 0x0001, 0x23d1: 0x0001, 0x23d2: 0x0001, 0x23d3: 0x0001, 0x23d4: 0x0001, 0x23d5: 0x0001, 0x23d6: 0x0001, 0x23d7: 0x0001, 0x23d8: 0x0001, 0x23d9: 0x0001, 0x23da: 0x0001, 0x23db: 0x0001, 0x23dc: 0x0001, 0x23dd: 0x0001, 0x23de: 0x0001, 0x23df: 0x0001, 0x23e0: 0x8000, 0x23e1: 0x8000, 0x23e2: 0x8000, 0x23e3: 0x8000, 0x23e4: 0x8000, 0x23e5: 0x8000, 0x23e6: 0x8000, 0x23e7: 0x8000, 0x23e8: 0x8000, 0x23e9: 0x8000, 0x23ea: 0x0001, 0x23eb: 0x0001, // Block 0x90, offset 0x2400 0x2400: 0x0001, 0x2401: 0x0001, 0x2402: 0x0001, 0x2403: 0x0001, 0x2404: 0x0001, 0x2405: 0x0001, 0x2406: 0x0001, 0x2407: 0x0001, 0x2408: 0x0001, 0x2409: 0x0001, 0x240a: 0x0001, 0x240b: 0x0001, 0x240c: 0x0001, 0x240d: 0x0001, 0x240e: 0x0001, 0x240f: 0x0001, 0x2410: 0x0001, 0x2411: 0x0001, 0x2412: 0x0001, 0x2413: 0x0001, 0x2414: 0x0001, 0x2415: 0x0001, 0x2416: 0x0001, 0x2417: 0x0001, 0x2418: 0x0001, 0x2419: 0x0001, 0x241a: 0x0001, 0x241b: 0x0001, 0x241c: 0x0001, 0x241d: 0x0001, 0x241e: 0x0001, 0x241f: 0x0001, 0x2420: 0x0001, 0x2421: 0x0001, 0x2422: 0x0001, 0x2423: 0x0001, 0x2424: 0x0001, 0x2425: 0x0001, 0x2426: 0x0001, 0x2427: 0x0001, 0x2428: 0x0001, 0x2429: 0x0001, 0x242a: 0x0001, 0x242b: 0x0001, 0x242c: 0x0001, 0x242d: 0x0001, 0x242e: 0x0001, 0x242f: 0x0010, 0x2430: 0x0010, 0x2431: 0x0010, 0x2432: 0x0010, 0x2434: 0x0010, 0x2435: 0x0010, 0x2436: 0x0010, 0x2437: 0x0010, 0x2438: 0x0010, 0x2439: 0x0010, 0x243a: 0x0010, 0x243b: 0x0010, 0x243c: 0x0010, 0x243d: 0x0010, 0x243f: 0x0001, // Block 0x91, offset 0x2440 0x2440: 0x0001, 0x2441: 0x0001, 0x2442: 0x0001, 0x2443: 0x0001, 0x2444: 0x0001, 0x2445: 0x0001, 0x2446: 0x0001, 0x2447: 0x0001, 0x2448: 0x0001, 0x2449: 0x0001, 0x244a: 0x0001, 0x244b: 0x0001, 0x244c: 0x0001, 0x244d: 0x0001, 0x244e: 0x0001, 0x244f: 0x0001, 0x2450: 0x0001, 0x2451: 0x0001, 0x2452: 0x0001, 0x2453: 0x0001, 0x2454: 0x0001, 0x2455: 0x0001, 0x2456: 0x0001, 0x2457: 0x0001, 0x2458: 0x0001, 0x2459: 0x0001, 0x245a: 0x0001, 0x245b: 0x0001, 0x245c: 0x0001, 0x245d: 0x0001, 0x245e: 0x0010, 0x245f: 0x0010, 0x2460: 0x0001, 0x2461: 0x0001, 0x2462: 0x0001, 0x2463: 0x0001, 0x2464: 0x0001, 0x2465: 0x0001, 0x2466: 0x0001, 0x2467: 0x0001, 0x2468: 0x0001, 0x2469: 0x0001, 0x246a: 0x0001, 0x246b: 0x0001, 0x246c: 0x0001, 0x246d: 0x0001, 0x246e: 0x0001, 0x246f: 0x0001, 0x2470: 0x0001, 0x2471: 0x0001, 0x2472: 0x0001, 0x2473: 0x0001, 0x2474: 0x0001, 0x2475: 0x0001, 0x2476: 0x0001, 0x2477: 0x0001, 0x2478: 0x0001, 0x2479: 0x0001, 0x247a: 0x0001, 0x247b: 0x0001, 0x247c: 0x0001, 0x247d: 0x0001, 0x247e: 0x0001, 0x247f: 0x0001, // Block 0x92, offset 0x2480 0x2480: 0x0001, 0x2481: 0x0001, 0x2482: 0x0001, 0x2483: 0x0001, 0x2484: 0x0001, 0x2485: 0x0001, 0x2486: 0x0001, 0x2487: 0x0001, 0x2488: 0x0001, 0x2489: 0x0001, 0x248a: 0x0001, 0x248b: 0x0001, 0x248c: 0x0001, 0x248d: 0x0001, 0x248e: 0x0001, 0x248f: 0x0001, 0x2490: 0x0001, 0x2491: 0x0001, 0x2492: 0x0001, 0x2493: 0x0001, 0x2494: 0x0001, 0x2495: 0x0001, 0x2496: 0x0001, 0x2497: 0x0001, 0x2498: 0x0001, 0x2499: 0x0001, 0x249a: 0x0001, 0x249b: 0x0001, 0x249c: 0x0001, 0x249d: 0x0001, 0x249e: 0x0001, 0x249f: 0x0001, 0x24a0: 0x0001, 0x24a1: 0x0001, 0x24a2: 0x0001, 0x24a3: 0x0001, 0x24a4: 0x0001, 0x24a5: 0x0001, 0x24a6: 0x0001, 0x24a7: 0x0001, 0x24a8: 0x0001, 0x24a9: 0x0001, 0x24aa: 0x0001, 0x24ab: 0x0001, 0x24ac: 0x0001, 0x24ad: 0x0001, 0x24ae: 0x0001, 0x24af: 0x0001, 0x24b0: 0x0010, 0x24b1: 0x0010, // Block 0x93, offset 0x24c0 0x24c8: 0x0001, 0x24c9: 0x0001, 0x24ca: 0x0001, 0x24cb: 0x0001, 0x24cc: 0x0001, 0x24cd: 0x0001, 0x24ce: 0x0001, 0x24cf: 0x0001, 0x24d0: 0x0001, 0x24d1: 0x0001, 0x24d2: 0x0001, 0x24d3: 0x0001, 0x24d4: 0x0001, 0x24d5: 0x0001, 0x24d6: 0x0001, 0x24d7: 0x0001, 0x24d8: 0x0001, 0x24d9: 0x0001, 0x24da: 0x0001, 0x24db: 0x0001, 0x24dc: 0x0001, 0x24dd: 0x0001, 0x24de: 0x0001, 0x24df: 0x0001, 0x24e0: 0x0001, 0x24e1: 0x0001, 0x24e2: 0x0001, 0x24e3: 0x0001, 0x24e4: 0x0001, 0x24e5: 0x0001, 0x24e6: 0x0001, 0x24e7: 0x0001, 0x24e8: 0x0001, 0x24e9: 0x0001, 0x24ea: 0x0001, 0x24eb: 0x0001, 0x24ec: 0x0001, 0x24ed: 0x0001, 0x24ee: 0x0001, 0x24ef: 0x0001, 0x24f0: 0x0001, 0x24f1: 0x0001, 0x24f2: 0x0001, 0x24f3: 0x0001, 0x24f4: 0x0001, 0x24f5: 0x0001, 0x24f6: 0x0001, 0x24f7: 0x0001, 0x24f8: 0x0001, 0x24f9: 0x0001, 0x24fa: 0x0001, 0x24fb: 0x0001, 0x24fc: 0x0001, 0x24fd: 0x0001, 0x24fe: 0x0001, 0x24ff: 0x0001, // Block 0x94, offset 0x2500 0x2500: 0x0001, 0x2501: 0x0001, 0x2502: 0x0001, 0x2503: 0x0001, 0x2504: 0x0001, 0x2505: 0x0001, 0x2506: 0x0001, 0x2507: 0x0001, 0x2508: 0x0001, 0x2509: 0x0001, 0x250a: 0x0001, 0x250b: 0x0001, 0x250c: 0x0001, 0x250d: 0x0001, 0x250e: 0x0001, 0x250f: 0x0001, 0x2510: 0x0001, 0x2511: 0x0001, 0x2512: 0x0001, 0x2513: 0x0001, 0x2514: 0x0001, 0x2515: 0x0001, 0x2516: 0x0001, 0x2517: 0x0001, 0x2518: 0x0001, 0x2519: 0x0001, 0x251a: 0x0001, 0x251b: 0x0001, 0x251c: 0x0001, 0x2531: 0x0001, 0x2532: 0x0001, 0x2533: 0x0001, 0x2534: 0x0001, 0x2535: 0x0001, 0x2536: 0x0001, 0x2537: 0x0001, 0x2538: 0x0001, 0x2539: 0x0001, 0x253a: 0x0001, 0x253b: 0x0001, 0x253c: 0x0001, 0x253d: 0x0001, 0x253e: 0x0001, 0x253f: 0x0001, // Block 0x95, offset 0x2540 0x2540: 0x0001, 0x2541: 0x0001, 0x2542: 0x0010, 0x2543: 0x0001, 0x2544: 0x0001, 0x2545: 0x0001, 0x2546: 0x0010, 0x2547: 0x0001, 0x2548: 0x0001, 0x2549: 0x0001, 0x254a: 0x0001, 0x254b: 0x0010, 0x254c: 0x0001, 0x254d: 0x0001, 0x254e: 0x0001, 0x254f: 0x0001, 0x2550: 0x0001, 0x2551: 0x0001, 0x2552: 0x0001, 0x2553: 0x0001, 0x2554: 0x0001, 0x2555: 0x0001, 0x2556: 0x0001, 0x2557: 0x0001, 0x2558: 0x0001, 0x2559: 0x0001, 0x255a: 0x0001, 0x255b: 0x0001, 0x255c: 0x0001, 0x255d: 0x0001, 0x255e: 0x0001, 0x255f: 0x0001, 0x2560: 0x0001, 0x2561: 0x0001, 0x2562: 0x0001, 0x2563: 0x0010, 0x2564: 0x0010, 0x2565: 0x0010, 0x2566: 0x0010, 0x2567: 0x0010, 0x256c: 0x0010, // Block 0x96, offset 0x2580 0x2580: 0x0001, 0x2581: 0x0001, 0x2582: 0x0001, 0x2583: 0x0001, 0x2584: 0x0001, 0x2585: 0x0001, 0x2586: 0x0001, 0x2587: 0x0001, 0x2588: 0x0001, 0x2589: 0x0001, 0x258a: 0x0001, 0x258b: 0x0001, 0x258c: 0x0001, 0x258d: 0x0001, 0x258e: 0x0001, 0x258f: 0x0001, 0x2590: 0x0001, 0x2591: 0x0001, 0x2592: 0x0001, 0x2593: 0x0001, 0x2594: 0x0001, 0x2595: 0x0001, 0x2596: 0x0001, 0x2597: 0x0001, 0x2598: 0x0001, 0x2599: 0x0001, 0x259a: 0x0001, 0x259b: 0x0001, 0x259c: 0x0001, 0x259d: 0x0001, 0x259e: 0x0001, 0x259f: 0x0001, 0x25a0: 0x0001, 0x25a1: 0x0001, 0x25a2: 0x0001, 0x25a3: 0x0001, 0x25a4: 0x0001, 0x25a5: 0x0001, 0x25a6: 0x0001, 0x25a7: 0x0001, 0x25a8: 0x0001, 0x25a9: 0x0001, 0x25aa: 0x0001, 0x25ab: 0x0001, 0x25ac: 0x0001, 0x25ad: 0x0001, 0x25ae: 0x0001, 0x25af: 0x0001, 0x25b0: 0x0001, 0x25b1: 0x0001, 0x25b2: 0x0001, 0x25b3: 0x0001, // Block 0x97, offset 0x25c0 0x25c0: 0x0010, 0x25c1: 0x0010, 0x25c2: 0x0001, 0x25c3: 0x0001, 0x25c4: 0x0001, 0x25c5: 0x0001, 0x25c6: 0x0001, 0x25c7: 0x0001, 0x25c8: 0x0001, 0x25c9: 0x0001, 0x25ca: 0x0001, 0x25cb: 0x0001, 0x25cc: 0x0001, 0x25cd: 0x0001, 0x25ce: 0x0001, 0x25cf: 0x0001, 0x25d0: 0x0001, 0x25d1: 0x0001, 0x25d2: 0x0001, 0x25d3: 0x0001, 0x25d4: 0x0001, 0x25d5: 0x0001, 0x25d6: 0x0001, 0x25d7: 0x0001, 0x25d8: 0x0001, 0x25d9: 0x0001, 0x25da: 0x0001, 0x25db: 0x0001, 0x25dc: 0x0001, 0x25dd: 0x0001, 0x25de: 0x0001, 0x25df: 0x0001, 0x25e0: 0x0001, 0x25e1: 0x0001, 0x25e2: 0x0001, 0x25e3: 0x0001, 0x25e4: 0x0001, 0x25e5: 0x0001, 0x25e6: 0x0001, 0x25e7: 0x0001, 0x25e8: 0x0001, 0x25e9: 0x0001, 0x25ea: 0x0001, 0x25eb: 0x0001, 0x25ec: 0x0001, 0x25ed: 0x0001, 0x25ee: 0x0001, 0x25ef: 0x0001, 0x25f0: 0x0001, 0x25f1: 0x0001, 0x25f2: 0x0001, 0x25f3: 0x0001, 0x25f4: 0x0010, 0x25f5: 0x0010, 0x25f6: 0x0010, 0x25f7: 0x0010, 0x25f8: 0x0010, 0x25f9: 0x0010, 0x25fa: 0x0010, 0x25fb: 0x0010, 0x25fc: 0x0010, 0x25fd: 0x0010, 0x25fe: 0x0010, 0x25ff: 0x0010, // Block 0x98, offset 0x2600 0x2600: 0x0010, 0x2601: 0x0010, 0x2602: 0x0010, 0x2603: 0x0010, 0x2604: 0x0010, 0x2605: 0x0010, 0x2610: 0x8000, 0x2611: 0x8000, 0x2612: 0x8000, 0x2613: 0x8000, 0x2614: 0x8000, 0x2615: 0x8000, 0x2616: 0x8000, 0x2617: 0x8000, 0x2618: 0x8000, 0x2619: 0x8000, 0x2620: 0x0010, 0x2621: 0x0010, 0x2622: 0x0010, 0x2623: 0x0010, 0x2624: 0x0010, 0x2625: 0x0010, 0x2626: 0x0010, 0x2627: 0x0010, 0x2628: 0x0010, 0x2629: 0x0010, 0x262a: 0x0010, 0x262b: 0x0010, 0x262c: 0x0010, 0x262d: 0x0010, 0x262e: 0x0010, 0x262f: 0x0010, 0x2630: 0x0010, 0x2631: 0x0010, 0x2632: 0x0001, 0x2633: 0x0001, 0x2634: 0x0001, 0x2635: 0x0001, 0x2636: 0x0001, 0x2637: 0x0001, 0x263b: 0x0001, 0x263d: 0x0001, 0x263e: 0x0001, 0x263f: 0x0010, // Block 0x99, offset 0x2640 0x2640: 0x8000, 0x2641: 0x8000, 0x2642: 0x8000, 0x2643: 0x8000, 0x2644: 0x8000, 0x2645: 0x8000, 0x2646: 0x8000, 0x2647: 0x8000, 0x2648: 0x8000, 0x2649: 0x8000, 0x264a: 0x0001, 0x264b: 0x0001, 0x264c: 0x0001, 0x264d: 0x0001, 0x264e: 0x0001, 0x264f: 0x0001, 0x2650: 0x0001, 0x2651: 0x0001, 0x2652: 0x0001, 0x2653: 0x0001, 0x2654: 0x0001, 0x2655: 0x0001, 0x2656: 0x0001, 0x2657: 0x0001, 0x2658: 0x0001, 0x2659: 0x0001, 0x265a: 0x0001, 0x265b: 0x0001, 0x265c: 0x0001, 0x265d: 0x0001, 0x265e: 0x0001, 0x265f: 0x0001, 0x2660: 0x0001, 0x2661: 0x0001, 0x2662: 0x0001, 0x2663: 0x0001, 0x2664: 0x0001, 0x2665: 0x0001, 0x2666: 0x0010, 0x2667: 0x0010, 0x2668: 0x0010, 0x2669: 0x0010, 0x266a: 0x0010, 0x266b: 0x0010, 0x266c: 0x0010, 0x266d: 0x0010, 0x2670: 0x0001, 0x2671: 0x0001, 0x2672: 0x0001, 0x2673: 0x0001, 0x2674: 0x0001, 0x2675: 0x0001, 0x2676: 0x0001, 0x2677: 0x0001, 0x2678: 0x0001, 0x2679: 0x0001, 0x267a: 0x0001, 0x267b: 0x0001, 0x267c: 0x0001, 0x267d: 0x0001, 0x267e: 0x0001, 0x267f: 0x0001, // Block 0x9a, offset 0x2680 0x2680: 0x0001, 0x2681: 0x0001, 0x2682: 0x0001, 0x2683: 0x0001, 0x2684: 0x0001, 0x2685: 0x0001, 0x2686: 0x0001, 0x2687: 0x0010, 0x2688: 0x0010, 0x2689: 0x0010, 0x268a: 0x0010, 0x268b: 0x0010, 0x268c: 0x0010, 0x268d: 0x0010, 0x268e: 0x0010, 0x268f: 0x0010, 0x2690: 0x0010, 0x2691: 0x0010, 0x2692: 0x0010, 0x2693: 0x0010, 0x26a0: 0x0001, 0x26a1: 0x0001, 0x26a2: 0x0001, 0x26a3: 0x0001, 0x26a4: 0x0001, 0x26a5: 0x0001, 0x26a6: 0x0001, 0x26a7: 0x0001, 0x26a8: 0x0001, 0x26a9: 0x0001, 0x26aa: 0x0001, 0x26ab: 0x0001, 0x26ac: 0x0001, 0x26ad: 0x0001, 0x26ae: 0x0001, 0x26af: 0x0001, 0x26b0: 0x0001, 0x26b1: 0x0001, 0x26b2: 0x0001, 0x26b3: 0x0001, 0x26b4: 0x0001, 0x26b5: 0x0001, 0x26b6: 0x0001, 0x26b7: 0x0001, 0x26b8: 0x0001, 0x26b9: 0x0001, 0x26ba: 0x0001, 0x26bb: 0x0001, 0x26bc: 0x0001, // Block 0x9b, offset 0x26c0 0x26c0: 0x0010, 0x26c1: 0x0010, 0x26c2: 0x0010, 0x26c3: 0x0010, 0x26c4: 0x0001, 0x26c5: 0x0001, 0x26c6: 0x0001, 0x26c7: 0x0001, 0x26c8: 0x0001, 0x26c9: 0x0001, 0x26ca: 0x0001, 0x26cb: 0x0001, 0x26cc: 0x0001, 0x26cd: 0x0001, 0x26ce: 0x0001, 0x26cf: 0x0001, 0x26d0: 0x0001, 0x26d1: 0x0001, 0x26d2: 0x0001, 0x26d3: 0x0001, 0x26d4: 0x0001, 0x26d5: 0x0001, 0x26d6: 0x0001, 0x26d7: 0x0001, 0x26d8: 0x0001, 0x26d9: 0x0001, 0x26da: 0x0001, 0x26db: 0x0001, 0x26dc: 0x0001, 0x26dd: 0x0001, 0x26de: 0x0001, 0x26df: 0x0001, 0x26e0: 0x0001, 0x26e1: 0x0001, 0x26e2: 0x0001, 0x26e3: 0x0001, 0x26e4: 0x0001, 0x26e5: 0x0001, 0x26e6: 0x0001, 0x26e7: 0x0001, 0x26e8: 0x0001, 0x26e9: 0x0001, 0x26ea: 0x0001, 0x26eb: 0x0001, 0x26ec: 0x0001, 0x26ed: 0x0001, 0x26ee: 0x0001, 0x26ef: 0x0001, 0x26f0: 0x0001, 0x26f1: 0x0001, 0x26f2: 0x0001, 0x26f3: 0x0010, 0x26f4: 0x0010, 0x26f5: 0x0010, 0x26f6: 0x0010, 0x26f7: 0x0010, 0x26f8: 0x0010, 0x26f9: 0x0010, 0x26fa: 0x0010, 0x26fb: 0x0010, 0x26fc: 0x0010, 0x26fd: 0x0010, 0x26fe: 0x0010, 0x26ff: 0x0010, // Block 0x9c, offset 0x2700 0x2700: 0x0010, 0x270f: 0x0001, 0x2710: 0x8000, 0x2711: 0x8000, 0x2712: 0x8000, 0x2713: 0x8000, 0x2714: 0x8000, 0x2715: 0x8000, 0x2716: 0x8000, 0x2717: 0x8000, 0x2718: 0x8000, 0x2719: 0x8000, 0x2725: 0x0010, 0x2730: 0x8000, 0x2731: 0x8000, 0x2732: 0x8000, 0x2733: 0x8000, 0x2734: 0x8000, 0x2735: 0x8000, 0x2736: 0x8000, 0x2737: 0x8000, 0x2738: 0x8000, 0x2739: 0x8000, // Block 0x9d, offset 0x2740 0x2740: 0x0001, 0x2741: 0x0001, 0x2742: 0x0001, 0x2743: 0x0001, 0x2744: 0x0001, 0x2745: 0x0001, 0x2746: 0x0001, 0x2747: 0x0001, 0x2748: 0x0001, 0x2749: 0x0001, 0x274a: 0x0001, 0x274b: 0x0001, 0x274c: 0x0001, 0x274d: 0x0001, 0x274e: 0x0001, 0x274f: 0x0001, 0x2750: 0x0001, 0x2751: 0x0001, 0x2752: 0x0001, 0x2753: 0x0001, 0x2754: 0x0001, 0x2755: 0x0001, 0x2756: 0x0001, 0x2757: 0x0001, 0x2758: 0x0001, 0x2759: 0x0001, 0x275a: 0x0001, 0x275b: 0x0001, 0x275c: 0x0001, 0x275d: 0x0001, 0x275e: 0x0001, 0x275f: 0x0001, 0x2760: 0x0001, 0x2761: 0x0001, 0x2762: 0x0001, 0x2763: 0x0001, 0x2764: 0x0001, 0x2765: 0x0001, 0x2766: 0x0001, 0x2767: 0x0001, 0x2768: 0x0001, 0x2769: 0x0010, 0x276a: 0x0010, 0x276b: 0x0010, 0x276c: 0x0010, 0x276d: 0x0010, 0x276e: 0x0010, 0x276f: 0x0010, 0x2770: 0x0010, 0x2771: 0x0010, 0x2772: 0x0010, 0x2773: 0x0010, 0x2774: 0x0010, 0x2775: 0x0010, 0x2776: 0x0010, // Block 0x9e, offset 0x2780 0x2780: 0x0001, 0x2781: 0x0001, 0x2782: 0x0001, 0x2783: 0x0010, 0x2784: 0x0001, 0x2785: 0x0001, 0x2786: 0x0001, 0x2787: 0x0001, 0x2788: 0x0001, 0x2789: 0x0001, 0x278a: 0x0001, 0x278b: 0x0001, 0x278c: 0x0010, 0x278d: 0x0010, 0x2790: 0x8000, 0x2791: 0x8000, 0x2792: 0x8000, 0x2793: 0x8000, 0x2794: 0x8000, 0x2795: 0x8000, 0x2796: 0x8000, 0x2797: 0x8000, 0x2798: 0x8000, 0x2799: 0x8000, 0x27bb: 0x0010, 0x27bc: 0x0010, 0x27bd: 0x0010, // Block 0x9f, offset 0x27c0 0x27f0: 0x0010, 0x27f2: 0x0010, 0x27f3: 0x0010, 0x27f4: 0x0010, 0x27f7: 0x0010, 0x27f8: 0x0010, 0x27fe: 0x0010, 0x27ff: 0x0010, // Block 0xa0, offset 0x2800 0x2801: 0x0010, 0x2820: 0x0001, 0x2821: 0x0001, 0x2822: 0x0001, 0x2823: 0x0001, 0x2824: 0x0001, 0x2825: 0x0001, 0x2826: 0x0001, 0x2827: 0x0001, 0x2828: 0x0001, 0x2829: 0x0001, 0x282a: 0x0001, 0x282b: 0x0010, 0x282c: 0x0010, 0x282d: 0x0010, 0x282e: 0x0010, 0x282f: 0x0010, 0x2832: 0x0001, 0x2833: 0x0001, 0x2834: 0x0001, 0x2835: 0x0010, 0x2836: 0x0010, // Block 0xa1, offset 0x2840 0x2841: 0x0001, 0x2842: 0x0001, 0x2843: 0x0001, 0x2844: 0x0001, 0x2845: 0x0001, 0x2846: 0x0001, 0x2849: 0x0001, 0x284a: 0x0001, 0x284b: 0x0001, 0x284c: 0x0001, 0x284d: 0x0001, 0x284e: 0x0001, 0x2851: 0x0001, 0x2852: 0x0001, 0x2853: 0x0001, 0x2854: 0x0001, 0x2855: 0x0001, 0x2856: 0x0001, 0x2860: 0x0001, 0x2861: 0x0001, 0x2862: 0x0001, 0x2863: 0x0001, 0x2864: 0x0001, 0x2865: 0x0001, 0x2866: 0x0001, 0x2868: 0x0001, 0x2869: 0x0001, 0x286a: 0x0001, 0x286b: 0x0001, 0x286c: 0x0001, 0x286d: 0x0001, 0x286e: 0x0001, 0x2870: 0x0001, 0x2871: 0x0001, 0x2872: 0x0001, 0x2873: 0x0001, 0x2874: 0x0001, 0x2875: 0x0001, 0x2876: 0x0001, 0x2877: 0x0001, 0x2878: 0x0001, 0x2879: 0x0001, 0x287a: 0x0001, 0x287b: 0x0001, 0x287c: 0x0001, 0x287d: 0x0001, 0x287e: 0x0001, 0x287f: 0x0001, // Block 0xa2, offset 0x2880 0x2880: 0x0001, 0x2881: 0x0001, 0x2882: 0x0001, 0x2883: 0x0001, 0x2884: 0x0001, 0x2885: 0x0001, 0x2886: 0x0001, 0x2887: 0x0001, 0x2888: 0x0001, 0x2889: 0x0001, 0x288a: 0x0001, 0x288b: 0x0001, 0x288c: 0x0001, 0x288d: 0x0001, 0x288e: 0x0001, 0x288f: 0x0001, 0x2890: 0x0001, 0x2891: 0x0001, 0x2892: 0x0001, 0x2893: 0x0001, 0x2894: 0x0001, 0x2895: 0x0001, 0x2896: 0x0001, 0x2897: 0x0001, 0x2898: 0x0001, 0x2899: 0x0001, 0x289a: 0x0001, 0x289b: 0x0001, 0x289c: 0x0001, 0x289d: 0x0001, 0x289e: 0x0001, 0x289f: 0x0001, 0x28a0: 0x0001, 0x28a1: 0x0001, 0x28a2: 0x0001, 0x28a3: 0x0001, 0x28a4: 0x0001, 0x28a5: 0x0001, 0x28a6: 0x0001, 0x28a7: 0x0001, 0x28a8: 0x0001, 0x28a9: 0x0001, 0x28b0: 0x0001, 0x28b1: 0x0001, 0x28b2: 0x0001, 0x28b3: 0x0001, 0x28b4: 0x0001, 0x28b5: 0x0001, 0x28b6: 0x0001, 0x28b7: 0x0001, 0x28b8: 0x0001, 0x28b9: 0x0001, 0x28ba: 0x0001, 0x28bb: 0x0001, 0x28bc: 0x0001, 0x28bd: 0x0001, 0x28be: 0x0001, 0x28bf: 0x0001, // Block 0xa3, offset 0x28c0 0x28c0: 0x0001, 0x28c1: 0x0001, 0x28c2: 0x0001, 0x28c3: 0x0001, 0x28c4: 0x0001, 0x28c5: 0x0001, 0x28c6: 0x0001, 0x28c7: 0x0001, 0x28c8: 0x0001, 0x28c9: 0x0001, 0x28ca: 0x0001, 0x28cb: 0x0001, 0x28cc: 0x0001, 0x28cd: 0x0001, 0x28ce: 0x0001, 0x28cf: 0x0001, 0x28d0: 0x0001, 0x28d1: 0x0001, 0x28d2: 0x0001, 0x28d3: 0x0001, 0x28d4: 0x0001, 0x28d5: 0x0001, 0x28d6: 0x0001, 0x28d7: 0x0001, 0x28d8: 0x0001, 0x28d9: 0x0001, 0x28da: 0x0001, 0x28db: 0x0001, 0x28dc: 0x0001, 0x28dd: 0x0001, 0x28de: 0x0001, 0x28df: 0x0001, 0x28e0: 0x0001, 0x28e1: 0x0001, 0x28e2: 0x0001, 0x28e3: 0x0010, 0x28e4: 0x0010, 0x28e5: 0x0010, 0x28e6: 0x0010, 0x28e7: 0x0010, 0x28e8: 0x0010, 0x28e9: 0x0010, 0x28ea: 0x0010, 0x28ec: 0x0010, 0x28ed: 0x0010, 0x28f0: 0x8000, 0x28f1: 0x8000, 0x28f2: 0x8000, 0x28f3: 0x8000, 0x28f4: 0x8000, 0x28f5: 0x8000, 0x28f6: 0x8000, 0x28f7: 0x8000, 0x28f8: 0x8000, 0x28f9: 0x8000, // Block 0xa4, offset 0x2900 0x2900: 0x0001, 0x2901: 0x0001, 0x2902: 0x0001, 0x2903: 0x0001, 0x2904: 0x0001, 0x2905: 0x0001, 0x2906: 0x0001, 0x2907: 0x0001, 0x2908: 0x0001, 0x2909: 0x0001, 0x290a: 0x0001, 0x290b: 0x0001, 0x290c: 0x0001, 0x290d: 0x0001, 0x290e: 0x0001, 0x290f: 0x0001, 0x2910: 0x0001, 0x2911: 0x0001, 0x2912: 0x0001, 0x2913: 0x0001, 0x2914: 0x0001, 0x2915: 0x0001, 0x2916: 0x0001, 0x2917: 0x0001, 0x2918: 0x0001, 0x2919: 0x0001, 0x291a: 0x0001, 0x291b: 0x0001, 0x291c: 0x0001, 0x291d: 0x0001, 0x291e: 0x0001, 0x291f: 0x0001, 0x2920: 0x0001, 0x2921: 0x0001, 0x2922: 0x0001, 0x2923: 0x0001, 0x2930: 0x0001, 0x2931: 0x0001, 0x2932: 0x0001, 0x2933: 0x0001, 0x2934: 0x0001, 0x2935: 0x0001, 0x2936: 0x0001, 0x2937: 0x0001, 0x2938: 0x0001, 0x2939: 0x0001, 0x293a: 0x0001, 0x293b: 0x0001, 0x293c: 0x0001, 0x293d: 0x0001, 0x293e: 0x0001, 0x293f: 0x0001, // Block 0xa5, offset 0x2940 0x2940: 0x0001, 0x2941: 0x0001, 0x2942: 0x0001, 0x2943: 0x0001, 0x2944: 0x0001, 0x2945: 0x0001, 0x2946: 0x0001, 0x294b: 0x0001, 0x294c: 0x0001, 0x294d: 0x0001, 0x294e: 0x0001, 0x294f: 0x0001, 0x2950: 0x0001, 0x2951: 0x0001, 0x2952: 0x0001, 0x2953: 0x0001, 0x2954: 0x0001, 0x2955: 0x0001, 0x2956: 0x0001, 0x2957: 0x0001, 0x2958: 0x0001, 0x2959: 0x0001, 0x295a: 0x0001, 0x295b: 0x0001, 0x295c: 0x0001, 0x295d: 0x0001, 0x295e: 0x0001, 0x295f: 0x0001, 0x2960: 0x0001, 0x2961: 0x0001, 0x2962: 0x0001, 0x2963: 0x0001, 0x2964: 0x0001, 0x2965: 0x0001, 0x2966: 0x0001, 0x2967: 0x0001, 0x2968: 0x0001, 0x2969: 0x0001, 0x296a: 0x0001, 0x296b: 0x0001, 0x296c: 0x0001, 0x296d: 0x0001, 0x296e: 0x0001, 0x296f: 0x0001, 0x2970: 0x0001, 0x2971: 0x0001, 0x2972: 0x0001, 0x2973: 0x0001, 0x2974: 0x0001, 0x2975: 0x0001, 0x2976: 0x0001, 0x2977: 0x0001, 0x2978: 0x0001, 0x2979: 0x0001, 0x297a: 0x0001, 0x297b: 0x0001, // Block 0xa6, offset 0x2980 0x2980: 0x0002, 0x2981: 0x0002, 0x2982: 0x0002, 0x2983: 0x0002, 0x2984: 0x0002, 0x2985: 0x0002, 0x2986: 0x0002, 0x2987: 0x0002, 0x2988: 0x0002, 0x2989: 0x0002, 0x298a: 0x0002, 0x298b: 0x0002, 0x298c: 0x0002, 0x298d: 0x0002, 0x298e: 0x0002, 0x298f: 0x0002, 0x2990: 0x0002, 0x2991: 0x0002, 0x2992: 0x0002, 0x2993: 0x0002, 0x2994: 0x0002, 0x2995: 0x0002, 0x2996: 0x0002, 0x2997: 0x0002, 0x2998: 0x0002, 0x2999: 0x0002, 0x299a: 0x0002, 0x299b: 0x0002, 0x299c: 0x0002, 0x299d: 0x0002, 0x299e: 0x0002, 0x299f: 0x0002, 0x29a0: 0x0002, 0x29a1: 0x0002, 0x29a2: 0x0002, 0x29a3: 0x0002, 0x29a4: 0x0002, 0x29a5: 0x0002, 0x29a6: 0x0002, 0x29a7: 0x0002, 0x29a8: 0x0002, 0x29a9: 0x0002, 0x29aa: 0x0002, 0x29ab: 0x0002, 0x29ac: 0x0002, 0x29ad: 0x0002, 0x29b0: 0x0002, 0x29b1: 0x0002, 0x29b2: 0x0002, 0x29b3: 0x0002, 0x29b4: 0x0002, 0x29b5: 0x0002, 0x29b6: 0x0002, 0x29b7: 0x0002, 0x29b8: 0x0002, 0x29b9: 0x0002, 0x29ba: 0x0002, 0x29bb: 0x0002, 0x29bc: 0x0002, 0x29bd: 0x0002, 0x29be: 0x0002, 0x29bf: 0x0002, // Block 0xa7, offset 0x29c0 0x29c0: 0x0002, 0x29c1: 0x0002, 0x29c2: 0x0002, 0x29c3: 0x0002, 0x29c4: 0x0002, 0x29c5: 0x0002, 0x29c6: 0x0002, 0x29c7: 0x0002, 0x29c8: 0x0002, 0x29c9: 0x0002, 0x29ca: 0x0002, 0x29cb: 0x0002, 0x29cc: 0x0002, 0x29cd: 0x0002, 0x29ce: 0x0002, 0x29cf: 0x0002, 0x29d0: 0x0002, 0x29d1: 0x0002, 0x29d2: 0x0002, 0x29d3: 0x0002, 0x29d4: 0x0002, 0x29d5: 0x0002, 0x29d6: 0x0002, 0x29d7: 0x0002, 0x29d8: 0x0002, 0x29d9: 0x0002, // Block 0xa8, offset 0x2a00 0x2a00: 0x0001, 0x2a01: 0x0001, 0x2a02: 0x0001, 0x2a03: 0x0001, 0x2a04: 0x0001, 0x2a05: 0x0001, 0x2a06: 0x0001, 0x2a13: 0x0001, 0x2a14: 0x0001, 0x2a15: 0x0001, 0x2a16: 0x0001, 0x2a17: 0x0001, 0x2a1d: 0x0100, 0x2a1e: 0x0010, 0x2a1f: 0x0100, 0x2a20: 0x0100, 0x2a21: 0x0100, 0x2a22: 0x0100, 0x2a23: 0x0100, 0x2a24: 0x0100, 0x2a25: 0x0100, 0x2a26: 0x0100, 0x2a27: 0x0100, 0x2a28: 0x0100, 0x2a2a: 0x0100, 0x2a2b: 0x0100, 0x2a2c: 0x0100, 0x2a2d: 0x0100, 0x2a2e: 0x0100, 0x2a2f: 0x0100, 0x2a30: 0x0100, 0x2a31: 0x0100, 0x2a32: 0x0100, 0x2a33: 0x0100, 0x2a34: 0x0100, 0x2a35: 0x0100, 0x2a36: 0x0100, 0x2a38: 0x0100, 0x2a39: 0x0100, 0x2a3a: 0x0100, 0x2a3b: 0x0100, 0x2a3c: 0x0100, 0x2a3e: 0x0100, // Block 0xa9, offset 0x2a40 0x2a40: 0x0100, 0x2a41: 0x0100, 0x2a43: 0x0100, 0x2a44: 0x0100, 0x2a46: 0x0100, 0x2a47: 0x0100, 0x2a48: 0x0100, 0x2a49: 0x0100, 0x2a4a: 0x0100, 0x2a4b: 0x0100, 0x2a4c: 0x0100, 0x2a4d: 0x0100, 0x2a4e: 0x0100, 0x2a4f: 0x0100, 0x2a50: 0x0001, 0x2a51: 0x0001, 0x2a52: 0x0001, 0x2a53: 0x0001, 0x2a54: 0x0001, 0x2a55: 0x0001, 0x2a56: 0x0001, 0x2a57: 0x0001, 0x2a58: 0x0001, 0x2a59: 0x0001, 0x2a5a: 0x0001, 0x2a5b: 0x0001, 0x2a5c: 0x0001, 0x2a5d: 0x0001, 0x2a5e: 0x0001, 0x2a5f: 0x0001, 0x2a60: 0x0001, 0x2a61: 0x0001, 0x2a62: 0x0001, 0x2a63: 0x0001, 0x2a64: 0x0001, 0x2a65: 0x0001, 0x2a66: 0x0001, 0x2a67: 0x0001, 0x2a68: 0x0001, 0x2a69: 0x0001, 0x2a6a: 0x0001, 0x2a6b: 0x0001, 0x2a6c: 0x0001, 0x2a6d: 0x0001, 0x2a6e: 0x0001, 0x2a6f: 0x0001, 0x2a70: 0x0001, 0x2a71: 0x0001, 0x2a72: 0x0001, 0x2a73: 0x0001, 0x2a74: 0x0001, 0x2a75: 0x0001, 0x2a76: 0x0001, 0x2a77: 0x0001, 0x2a78: 0x0001, 0x2a79: 0x0001, 0x2a7a: 0x0001, 0x2a7b: 0x0001, 0x2a7c: 0x0001, 0x2a7d: 0x0001, 0x2a7e: 0x0001, 0x2a7f: 0x0001, // Block 0xaa, offset 0x2a80 0x2a80: 0x0001, 0x2a81: 0x0001, 0x2a82: 0x0001, 0x2a83: 0x0001, 0x2a84: 0x0001, 0x2a85: 0x0001, 0x2a86: 0x0001, 0x2a87: 0x0001, 0x2a88: 0x0001, 0x2a89: 0x0001, 0x2a8a: 0x0001, 0x2a8b: 0x0001, 0x2a8c: 0x0001, 0x2a8d: 0x0001, 0x2a8e: 0x0001, 0x2a8f: 0x0001, 0x2a90: 0x0001, 0x2a91: 0x0001, 0x2a92: 0x0001, 0x2a93: 0x0001, 0x2a94: 0x0001, 0x2a95: 0x0001, 0x2a96: 0x0001, 0x2a97: 0x0001, 0x2a98: 0x0001, 0x2a99: 0x0001, 0x2a9a: 0x0001, 0x2a9b: 0x0001, 0x2a9c: 0x0001, 0x2a9d: 0x0001, 0x2a9e: 0x0001, 0x2a9f: 0x0001, 0x2aa0: 0x0001, 0x2aa1: 0x0001, 0x2aa2: 0x0001, 0x2aa3: 0x0001, 0x2aa4: 0x0001, 0x2aa5: 0x0001, 0x2aa6: 0x0001, 0x2aa7: 0x0001, 0x2aa8: 0x0001, 0x2aa9: 0x0001, 0x2aaa: 0x0001, 0x2aab: 0x0001, 0x2aac: 0x0001, 0x2aad: 0x0001, 0x2aae: 0x0001, 0x2aaf: 0x0001, 0x2ab0: 0x0001, 0x2ab1: 0x0001, // Block 0xab, offset 0x2ac0 0x2ad3: 0x0001, 0x2ad4: 0x0001, 0x2ad5: 0x0001, 0x2ad6: 0x0001, 0x2ad7: 0x0001, 0x2ad8: 0x0001, 0x2ad9: 0x0001, 0x2ada: 0x0001, 0x2adb: 0x0001, 0x2adc: 0x0001, 0x2add: 0x0001, 0x2ade: 0x0001, 0x2adf: 0x0001, 0x2ae0: 0x0001, 0x2ae1: 0x0001, 0x2ae2: 0x0001, 0x2ae3: 0x0001, 0x2ae4: 0x0001, 0x2ae5: 0x0001, 0x2ae6: 0x0001, 0x2ae7: 0x0001, 0x2ae8: 0x0001, 0x2ae9: 0x0001, 0x2aea: 0x0001, 0x2aeb: 0x0001, 0x2aec: 0x0001, 0x2aed: 0x0001, 0x2aee: 0x0001, 0x2aef: 0x0001, 0x2af0: 0x0001, 0x2af1: 0x0001, 0x2af2: 0x0001, 0x2af3: 0x0001, 0x2af4: 0x0001, 0x2af5: 0x0001, 0x2af6: 0x0001, 0x2af7: 0x0001, 0x2af8: 0x0001, 0x2af9: 0x0001, 0x2afa: 0x0001, 0x2afb: 0x0001, 0x2afc: 0x0001, 0x2afd: 0x0001, 0x2afe: 0x0001, 0x2aff: 0x0001, // Block 0xac, offset 0x2b00 0x2b00: 0x0001, 0x2b01: 0x0001, 0x2b02: 0x0001, 0x2b03: 0x0001, 0x2b04: 0x0001, 0x2b05: 0x0001, 0x2b06: 0x0001, 0x2b07: 0x0001, 0x2b08: 0x0001, 0x2b09: 0x0001, 0x2b0a: 0x0001, 0x2b0b: 0x0001, 0x2b0c: 0x0001, 0x2b0d: 0x0001, 0x2b0e: 0x0001, 0x2b0f: 0x0001, 0x2b10: 0x0001, 0x2b11: 0x0001, 0x2b12: 0x0001, 0x2b13: 0x0001, 0x2b14: 0x0001, 0x2b15: 0x0001, 0x2b16: 0x0001, 0x2b17: 0x0001, 0x2b18: 0x0001, 0x2b19: 0x0001, 0x2b1a: 0x0001, 0x2b1b: 0x0001, 0x2b1c: 0x0001, 0x2b1d: 0x0001, 0x2b1e: 0x0001, 0x2b1f: 0x0001, 0x2b20: 0x0001, 0x2b21: 0x0001, 0x2b22: 0x0001, 0x2b23: 0x0001, 0x2b24: 0x0001, 0x2b25: 0x0001, 0x2b26: 0x0001, 0x2b27: 0x0001, 0x2b28: 0x0001, 0x2b29: 0x0001, 0x2b2a: 0x0001, 0x2b2b: 0x0001, 0x2b2c: 0x0001, 0x2b2d: 0x0001, 0x2b2e: 0x0001, 0x2b2f: 0x0001, 0x2b30: 0x0001, 0x2b31: 0x0001, 0x2b32: 0x0001, 0x2b33: 0x0001, 0x2b34: 0x0001, 0x2b35: 0x0001, 0x2b36: 0x0001, 0x2b37: 0x0001, 0x2b38: 0x0001, 0x2b39: 0x0001, 0x2b3a: 0x0001, 0x2b3b: 0x0001, 0x2b3c: 0x0001, 0x2b3d: 0x0001, // Block 0xad, offset 0x2b40 0x2b50: 0x0001, 0x2b51: 0x0001, 0x2b52: 0x0001, 0x2b53: 0x0001, 0x2b54: 0x0001, 0x2b55: 0x0001, 0x2b56: 0x0001, 0x2b57: 0x0001, 0x2b58: 0x0001, 0x2b59: 0x0001, 0x2b5a: 0x0001, 0x2b5b: 0x0001, 0x2b5c: 0x0001, 0x2b5d: 0x0001, 0x2b5e: 0x0001, 0x2b5f: 0x0001, 0x2b60: 0x0001, 0x2b61: 0x0001, 0x2b62: 0x0001, 0x2b63: 0x0001, 0x2b64: 0x0001, 0x2b65: 0x0001, 0x2b66: 0x0001, 0x2b67: 0x0001, 0x2b68: 0x0001, 0x2b69: 0x0001, 0x2b6a: 0x0001, 0x2b6b: 0x0001, 0x2b6c: 0x0001, 0x2b6d: 0x0001, 0x2b6e: 0x0001, 0x2b6f: 0x0001, 0x2b70: 0x0001, 0x2b71: 0x0001, 0x2b72: 0x0001, 0x2b73: 0x0001, 0x2b74: 0x0001, 0x2b75: 0x0001, 0x2b76: 0x0001, 0x2b77: 0x0001, 0x2b78: 0x0001, 0x2b79: 0x0001, 0x2b7a: 0x0001, 0x2b7b: 0x0001, 0x2b7c: 0x0001, 0x2b7d: 0x0001, 0x2b7e: 0x0001, 0x2b7f: 0x0001, // Block 0xae, offset 0x2b80 0x2b80: 0x0001, 0x2b81: 0x0001, 0x2b82: 0x0001, 0x2b83: 0x0001, 0x2b84: 0x0001, 0x2b85: 0x0001, 0x2b86: 0x0001, 0x2b87: 0x0001, 0x2b88: 0x0001, 0x2b89: 0x0001, 0x2b8a: 0x0001, 0x2b8b: 0x0001, 0x2b8c: 0x0001, 0x2b8d: 0x0001, 0x2b8e: 0x0001, 0x2b8f: 0x0001, 0x2b92: 0x0001, 0x2b93: 0x0001, 0x2b94: 0x0001, 0x2b95: 0x0001, 0x2b96: 0x0001, 0x2b97: 0x0001, 0x2b98: 0x0001, 0x2b99: 0x0001, 0x2b9a: 0x0001, 0x2b9b: 0x0001, 0x2b9c: 0x0001, 0x2b9d: 0x0001, 0x2b9e: 0x0001, 0x2b9f: 0x0001, 0x2ba0: 0x0001, 0x2ba1: 0x0001, 0x2ba2: 0x0001, 0x2ba3: 0x0001, 0x2ba4: 0x0001, 0x2ba5: 0x0001, 0x2ba6: 0x0001, 0x2ba7: 0x0001, 0x2ba8: 0x0001, 0x2ba9: 0x0001, 0x2baa: 0x0001, 0x2bab: 0x0001, 0x2bac: 0x0001, 0x2bad: 0x0001, 0x2bae: 0x0001, 0x2baf: 0x0001, 0x2bb0: 0x0001, 0x2bb1: 0x0001, 0x2bb2: 0x0001, 0x2bb3: 0x0001, 0x2bb4: 0x0001, 0x2bb5: 0x0001, 0x2bb6: 0x0001, 0x2bb7: 0x0001, 0x2bb8: 0x0001, 0x2bb9: 0x0001, 0x2bba: 0x0001, 0x2bbb: 0x0001, 0x2bbc: 0x0001, 0x2bbd: 0x0001, 0x2bbe: 0x0001, 0x2bbf: 0x0001, // Block 0xaf, offset 0x2bc0 0x2bc0: 0x0001, 0x2bc1: 0x0001, 0x2bc2: 0x0001, 0x2bc3: 0x0001, 0x2bc4: 0x0001, 0x2bc5: 0x0001, 0x2bc6: 0x0001, 0x2bc7: 0x0001, 0x2bf0: 0x0001, 0x2bf1: 0x0001, 0x2bf2: 0x0001, 0x2bf3: 0x0001, 0x2bf4: 0x0001, 0x2bf5: 0x0001, 0x2bf6: 0x0001, 0x2bf7: 0x0001, 0x2bf8: 0x0001, 0x2bf9: 0x0001, 0x2bfa: 0x0001, 0x2bfb: 0x0001, // Block 0xb0, offset 0x2c00 0x2c00: 0x0010, 0x2c01: 0x0010, 0x2c02: 0x0010, 0x2c03: 0x0010, 0x2c04: 0x0010, 0x2c05: 0x0010, 0x2c06: 0x0010, 0x2c07: 0x0010, 0x2c08: 0x0010, 0x2c09: 0x0010, 0x2c0a: 0x0010, 0x2c0b: 0x0010, 0x2c0c: 0x0010, 0x2c0d: 0x0010, 0x2c0e: 0x0010, 0x2c0f: 0x0010, 0x2c13: 0x0800, 0x2c20: 0x0010, 0x2c21: 0x0010, 0x2c22: 0x0010, 0x2c23: 0x0010, 0x2c24: 0x0010, 0x2c25: 0x0010, 0x2c26: 0x0010, 0x2c27: 0x0010, 0x2c28: 0x0010, 0x2c29: 0x0010, 0x2c2a: 0x0010, 0x2c2b: 0x0010, 0x2c2c: 0x0010, 0x2c2d: 0x0010, 0x2c2e: 0x0010, 0x2c2f: 0x0010, 0x2c33: 0x0020, 0x2c34: 0x0020, // Block 0xb1, offset 0x2c40 0x2c4d: 0x0020, 0x2c4e: 0x0020, 0x2c4f: 0x0020, 0x2c50: 0x1000, 0x2c52: 0x2000, 0x2c54: 0x1000, 0x2c55: 0x0800, 0x2c70: 0x0001, 0x2c71: 0x0001, 0x2c72: 0x0001, 0x2c73: 0x0001, 0x2c74: 0x0001, 0x2c76: 0x0001, 0x2c77: 0x0001, 0x2c78: 0x0001, 0x2c79: 0x0001, 0x2c7a: 0x0001, 0x2c7b: 0x0001, 0x2c7c: 0x0001, 0x2c7d: 0x0001, 0x2c7e: 0x0001, 0x2c7f: 0x0001, // Block 0xb2, offset 0x2c80 0x2c80: 0x0001, 0x2c81: 0x0001, 0x2c82: 0x0001, 0x2c83: 0x0001, 0x2c84: 0x0001, 0x2c85: 0x0001, 0x2c86: 0x0001, 0x2c87: 0x0001, 0x2c88: 0x0001, 0x2c89: 0x0001, 0x2c8a: 0x0001, 0x2c8b: 0x0001, 0x2c8c: 0x0001, 0x2c8d: 0x0001, 0x2c8e: 0x0001, 0x2c8f: 0x0001, 0x2c90: 0x0001, 0x2c91: 0x0001, 0x2c92: 0x0001, 0x2c93: 0x0001, 0x2c94: 0x0001, 0x2c95: 0x0001, 0x2c96: 0x0001, 0x2c97: 0x0001, 0x2c98: 0x0001, 0x2c99: 0x0001, 0x2c9a: 0x0001, 0x2c9b: 0x0001, 0x2c9c: 0x0001, 0x2c9d: 0x0001, 0x2c9e: 0x0001, 0x2c9f: 0x0001, 0x2ca0: 0x0001, 0x2ca1: 0x0001, 0x2ca2: 0x0001, 0x2ca3: 0x0001, 0x2ca4: 0x0001, 0x2ca5: 0x0001, 0x2ca6: 0x0001, 0x2ca7: 0x0001, 0x2ca8: 0x0001, 0x2ca9: 0x0001, 0x2caa: 0x0001, 0x2cab: 0x0001, 0x2cac: 0x0001, 0x2cad: 0x0001, 0x2cae: 0x0001, 0x2caf: 0x0001, 0x2cb0: 0x0001, 0x2cb1: 0x0001, 0x2cb2: 0x0001, 0x2cb3: 0x0001, 0x2cb4: 0x0001, 0x2cb5: 0x0001, 0x2cb6: 0x0001, 0x2cb7: 0x0001, 0x2cb8: 0x0001, 0x2cb9: 0x0001, 0x2cba: 0x0001, 0x2cbb: 0x0001, 0x2cbc: 0x0001, 0x2cbf: 0x0080, // Block 0xb3, offset 0x2cc0 0x2cc7: 0x2000, 0x2ccc: 0x1000, 0x2cce: 0x2000, 0x2cd0: 0x8000, 0x2cd1: 0x8000, 0x2cd2: 0x8000, 0x2cd3: 0x8000, 0x2cd4: 0x8000, 0x2cd5: 0x8000, 0x2cd6: 0x8000, 0x2cd7: 0x8000, 0x2cd8: 0x8000, 0x2cd9: 0x8000, 0x2cda: 0x0800, 0x2cdb: 0x1000, 0x2ce1: 0x0001, 0x2ce2: 0x0001, 0x2ce3: 0x0001, 0x2ce4: 0x0001, 0x2ce5: 0x0001, 0x2ce6: 0x0001, 0x2ce7: 0x0001, 0x2ce8: 0x0001, 0x2ce9: 0x0001, 0x2cea: 0x0001, 0x2ceb: 0x0001, 0x2cec: 0x0001, 0x2ced: 0x0001, 0x2cee: 0x0001, 0x2cef: 0x0001, 0x2cf0: 0x0001, 0x2cf1: 0x0001, 0x2cf2: 0x0001, 0x2cf3: 0x0001, 0x2cf4: 0x0001, 0x2cf5: 0x0001, 0x2cf6: 0x0001, 0x2cf7: 0x0001, 0x2cf8: 0x0001, 0x2cf9: 0x0001, 0x2cfa: 0x0001, 0x2cff: 0x0020, // Block 0xb4, offset 0x2d00 0x2d01: 0x0001, 0x2d02: 0x0001, 0x2d03: 0x0001, 0x2d04: 0x0001, 0x2d05: 0x0001, 0x2d06: 0x0001, 0x2d07: 0x0001, 0x2d08: 0x0001, 0x2d09: 0x0001, 0x2d0a: 0x0001, 0x2d0b: 0x0001, 0x2d0c: 0x0001, 0x2d0d: 0x0001, 0x2d0e: 0x0001, 0x2d0f: 0x0001, 0x2d10: 0x0001, 0x2d11: 0x0001, 0x2d12: 0x0001, 0x2d13: 0x0001, 0x2d14: 0x0001, 0x2d15: 0x0001, 0x2d16: 0x0001, 0x2d17: 0x0001, 0x2d18: 0x0001, 0x2d19: 0x0001, 0x2d1a: 0x0001, 0x2d26: 0x0202, 0x2d27: 0x0202, 0x2d28: 0x0202, 0x2d29: 0x0202, 0x2d2a: 0x0202, 0x2d2b: 0x0202, 0x2d2c: 0x0202, 0x2d2d: 0x0202, 0x2d2e: 0x0202, 0x2d2f: 0x0202, 0x2d30: 0x0202, 0x2d31: 0x0202, 0x2d32: 0x0202, 0x2d33: 0x0202, 0x2d34: 0x0202, 0x2d35: 0x0202, 0x2d36: 0x0202, 0x2d37: 0x0202, 0x2d38: 0x0202, 0x2d39: 0x0202, 0x2d3a: 0x0202, 0x2d3b: 0x0202, 0x2d3c: 0x0202, 0x2d3d: 0x0202, 0x2d3e: 0x0202, 0x2d3f: 0x0202, // Block 0xb5, offset 0x2d40 0x2d40: 0x0202, 0x2d41: 0x0202, 0x2d42: 0x0202, 0x2d43: 0x0202, 0x2d44: 0x0202, 0x2d45: 0x0202, 0x2d46: 0x0202, 0x2d47: 0x0202, 0x2d48: 0x0202, 0x2d49: 0x0202, 0x2d4a: 0x0202, 0x2d4b: 0x0202, 0x2d4c: 0x0202, 0x2d4d: 0x0202, 0x2d4e: 0x0202, 0x2d4f: 0x0202, 0x2d50: 0x0202, 0x2d51: 0x0202, 0x2d52: 0x0202, 0x2d53: 0x0202, 0x2d54: 0x0202, 0x2d55: 0x0202, 0x2d56: 0x0202, 0x2d57: 0x0202, 0x2d58: 0x0202, 0x2d59: 0x0202, 0x2d5a: 0x0202, 0x2d5b: 0x0202, 0x2d5c: 0x0202, 0x2d5d: 0x0202, 0x2d5e: 0x0010, 0x2d5f: 0x0010, 0x2d60: 0x0001, 0x2d61: 0x0001, 0x2d62: 0x0001, 0x2d63: 0x0001, 0x2d64: 0x0001, 0x2d65: 0x0001, 0x2d66: 0x0001, 0x2d67: 0x0001, 0x2d68: 0x0001, 0x2d69: 0x0001, 0x2d6a: 0x0001, 0x2d6b: 0x0001, 0x2d6c: 0x0001, 0x2d6d: 0x0001, 0x2d6e: 0x0001, 0x2d6f: 0x0001, 0x2d70: 0x0001, 0x2d71: 0x0001, 0x2d72: 0x0001, 0x2d73: 0x0001, 0x2d74: 0x0001, 0x2d75: 0x0001, 0x2d76: 0x0001, 0x2d77: 0x0001, 0x2d78: 0x0001, 0x2d79: 0x0001, 0x2d7a: 0x0001, 0x2d7b: 0x0001, 0x2d7c: 0x0001, 0x2d7d: 0x0001, 0x2d7e: 0x0001, // Block 0xb6, offset 0x2d80 0x2d82: 0x0001, 0x2d83: 0x0001, 0x2d84: 0x0001, 0x2d85: 0x0001, 0x2d86: 0x0001, 0x2d87: 0x0001, 0x2d8a: 0x0001, 0x2d8b: 0x0001, 0x2d8c: 0x0001, 0x2d8d: 0x0001, 0x2d8e: 0x0001, 0x2d8f: 0x0001, 0x2d92: 0x0001, 0x2d93: 0x0001, 0x2d94: 0x0001, 0x2d95: 0x0001, 0x2d96: 0x0001, 0x2d97: 0x0001, 0x2d9a: 0x0001, 0x2d9b: 0x0001, 0x2d9c: 0x0001, 0x2db9: 0x0080, 0x2dba: 0x0080, 0x2dbb: 0x0080, // Block 0xb7, offset 0x2dc0 0x2dc0: 0x0001, 0x2dc1: 0x0001, 0x2dc2: 0x0001, 0x2dc3: 0x0001, 0x2dc4: 0x0001, 0x2dc5: 0x0001, 0x2dc6: 0x0001, 0x2dc7: 0x0001, 0x2dc8: 0x0001, 0x2dc9: 0x0001, 0x2dca: 0x0001, 0x2dcb: 0x0001, 0x2dcd: 0x0001, 0x2dce: 0x0001, 0x2dcf: 0x0001, 0x2dd0: 0x0001, 0x2dd1: 0x0001, 0x2dd2: 0x0001, 0x2dd3: 0x0001, 0x2dd4: 0x0001, 0x2dd5: 0x0001, 0x2dd6: 0x0001, 0x2dd7: 0x0001, 0x2dd8: 0x0001, 0x2dd9: 0x0001, 0x2dda: 0x0001, 0x2ddb: 0x0001, 0x2ddc: 0x0001, 0x2ddd: 0x0001, 0x2dde: 0x0001, 0x2ddf: 0x0001, 0x2de0: 0x0001, 0x2de1: 0x0001, 0x2de2: 0x0001, 0x2de3: 0x0001, 0x2de4: 0x0001, 0x2de5: 0x0001, 0x2de6: 0x0001, 0x2de8: 0x0001, 0x2de9: 0x0001, 0x2dea: 0x0001, 0x2deb: 0x0001, 0x2dec: 0x0001, 0x2ded: 0x0001, 0x2dee: 0x0001, 0x2def: 0x0001, 0x2df0: 0x0001, 0x2df1: 0x0001, 0x2df2: 0x0001, 0x2df3: 0x0001, 0x2df4: 0x0001, 0x2df5: 0x0001, 0x2df6: 0x0001, 0x2df7: 0x0001, 0x2df8: 0x0001, 0x2df9: 0x0001, 0x2dfa: 0x0001, 0x2dfc: 0x0001, 0x2dfd: 0x0001, 0x2dff: 0x0001, // Block 0xb8, offset 0x2e00 0x2e00: 0x0001, 0x2e01: 0x0001, 0x2e02: 0x0001, 0x2e03: 0x0001, 0x2e04: 0x0001, 0x2e05: 0x0001, 0x2e06: 0x0001, 0x2e07: 0x0001, 0x2e08: 0x0001, 0x2e09: 0x0001, 0x2e0a: 0x0001, 0x2e0b: 0x0001, 0x2e0c: 0x0001, 0x2e0d: 0x0001, 0x2e10: 0x0001, 0x2e11: 0x0001, 0x2e12: 0x0001, 0x2e13: 0x0001, 0x2e14: 0x0001, 0x2e15: 0x0001, 0x2e16: 0x0001, 0x2e17: 0x0001, 0x2e18: 0x0001, 0x2e19: 0x0001, 0x2e1a: 0x0001, 0x2e1b: 0x0001, 0x2e1c: 0x0001, 0x2e1d: 0x0001, // Block 0xb9, offset 0x2e40 0x2e40: 0x0001, 0x2e41: 0x0001, 0x2e42: 0x0001, 0x2e43: 0x0001, 0x2e44: 0x0001, 0x2e45: 0x0001, 0x2e46: 0x0001, 0x2e47: 0x0001, 0x2e48: 0x0001, 0x2e49: 0x0001, 0x2e4a: 0x0001, 0x2e4b: 0x0001, 0x2e4c: 0x0001, 0x2e4d: 0x0001, 0x2e4e: 0x0001, 0x2e4f: 0x0001, 0x2e50: 0x0001, 0x2e51: 0x0001, 0x2e52: 0x0001, 0x2e53: 0x0001, 0x2e54: 0x0001, 0x2e55: 0x0001, 0x2e56: 0x0001, 0x2e57: 0x0001, 0x2e58: 0x0001, 0x2e59: 0x0001, 0x2e5a: 0x0001, 0x2e5b: 0x0001, 0x2e5c: 0x0001, 0x2e5d: 0x0001, 0x2e5e: 0x0001, 0x2e5f: 0x0001, 0x2e60: 0x0001, 0x2e61: 0x0001, 0x2e62: 0x0001, 0x2e63: 0x0001, 0x2e64: 0x0001, 0x2e65: 0x0001, 0x2e66: 0x0001, 0x2e67: 0x0001, 0x2e68: 0x0001, 0x2e69: 0x0001, 0x2e6a: 0x0001, 0x2e6b: 0x0001, 0x2e6c: 0x0001, 0x2e6d: 0x0001, 0x2e6e: 0x0001, 0x2e6f: 0x0001, 0x2e70: 0x0001, 0x2e71: 0x0001, 0x2e72: 0x0001, 0x2e73: 0x0001, 0x2e74: 0x0001, 0x2e75: 0x0001, 0x2e76: 0x0001, 0x2e77: 0x0001, 0x2e78: 0x0001, 0x2e79: 0x0001, 0x2e7a: 0x0001, // Block 0xba, offset 0x2e80 0x2e80: 0x0001, 0x2e81: 0x0001, 0x2e82: 0x0001, 0x2e83: 0x0001, 0x2e84: 0x0001, 0x2e85: 0x0001, 0x2e86: 0x0001, 0x2e87: 0x0001, 0x2e88: 0x0001, 0x2e89: 0x0001, 0x2e8a: 0x0001, 0x2e8b: 0x0001, 0x2e8c: 0x0001, 0x2e8d: 0x0001, 0x2e8e: 0x0001, 0x2e8f: 0x0001, 0x2e90: 0x0001, 0x2e91: 0x0001, 0x2e92: 0x0001, 0x2e93: 0x0001, 0x2e94: 0x0001, 0x2e95: 0x0001, 0x2e96: 0x0001, 0x2e97: 0x0001, 0x2e98: 0x0001, 0x2e99: 0x0001, 0x2e9a: 0x0001, 0x2e9b: 0x0001, 0x2e9c: 0x0001, 0x2e9d: 0x0001, 0x2e9e: 0x0001, 0x2e9f: 0x0001, 0x2ea0: 0x0001, 0x2ea1: 0x0001, 0x2ea2: 0x0001, 0x2ea3: 0x0001, 0x2ea4: 0x0001, 0x2ea5: 0x0001, 0x2ea6: 0x0001, 0x2ea7: 0x0001, 0x2ea8: 0x0001, 0x2ea9: 0x0001, 0x2eaa: 0x0001, 0x2eab: 0x0001, 0x2eac: 0x0001, 0x2ead: 0x0001, 0x2eae: 0x0001, 0x2eaf: 0x0001, 0x2eb0: 0x0001, 0x2eb1: 0x0001, 0x2eb2: 0x0001, 0x2eb3: 0x0001, 0x2eb4: 0x0001, // Block 0xbb, offset 0x2ec0 0x2efd: 0x0010, // Block 0xbc, offset 0x2f00 0x2f00: 0x0001, 0x2f01: 0x0001, 0x2f02: 0x0001, 0x2f03: 0x0001, 0x2f04: 0x0001, 0x2f05: 0x0001, 0x2f06: 0x0001, 0x2f07: 0x0001, 0x2f08: 0x0001, 0x2f09: 0x0001, 0x2f0a: 0x0001, 0x2f0b: 0x0001, 0x2f0c: 0x0001, 0x2f0d: 0x0001, 0x2f0e: 0x0001, 0x2f0f: 0x0001, 0x2f10: 0x0001, 0x2f11: 0x0001, 0x2f12: 0x0001, 0x2f13: 0x0001, 0x2f14: 0x0001, 0x2f15: 0x0001, 0x2f16: 0x0001, 0x2f17: 0x0001, 0x2f18: 0x0001, 0x2f19: 0x0001, 0x2f1a: 0x0001, 0x2f1b: 0x0001, 0x2f1c: 0x0001, 0x2f20: 0x0001, 0x2f21: 0x0001, 0x2f22: 0x0001, 0x2f23: 0x0001, 0x2f24: 0x0001, 0x2f25: 0x0001, 0x2f26: 0x0001, 0x2f27: 0x0001, 0x2f28: 0x0001, 0x2f29: 0x0001, 0x2f2a: 0x0001, 0x2f2b: 0x0001, 0x2f2c: 0x0001, 0x2f2d: 0x0001, 0x2f2e: 0x0001, 0x2f2f: 0x0001, 0x2f30: 0x0001, 0x2f31: 0x0001, 0x2f32: 0x0001, 0x2f33: 0x0001, 0x2f34: 0x0001, 0x2f35: 0x0001, 0x2f36: 0x0001, 0x2f37: 0x0001, 0x2f38: 0x0001, 0x2f39: 0x0001, 0x2f3a: 0x0001, 0x2f3b: 0x0001, 0x2f3c: 0x0001, 0x2f3d: 0x0001, 0x2f3e: 0x0001, 0x2f3f: 0x0001, // Block 0xbd, offset 0x2f40 0x2f40: 0x0001, 0x2f41: 0x0001, 0x2f42: 0x0001, 0x2f43: 0x0001, 0x2f44: 0x0001, 0x2f45: 0x0001, 0x2f46: 0x0001, 0x2f47: 0x0001, 0x2f48: 0x0001, 0x2f49: 0x0001, 0x2f4a: 0x0001, 0x2f4b: 0x0001, 0x2f4c: 0x0001, 0x2f4d: 0x0001, 0x2f4e: 0x0001, 0x2f4f: 0x0001, 0x2f50: 0x0001, 0x2f60: 0x0010, // Block 0xbe, offset 0x2f80 0x2f80: 0x0001, 0x2f81: 0x0001, 0x2f82: 0x0001, 0x2f83: 0x0001, 0x2f84: 0x0001, 0x2f85: 0x0001, 0x2f86: 0x0001, 0x2f87: 0x0001, 0x2f88: 0x0001, 0x2f89: 0x0001, 0x2f8a: 0x0001, 0x2f8b: 0x0001, 0x2f8c: 0x0001, 0x2f8d: 0x0001, 0x2f8e: 0x0001, 0x2f8f: 0x0001, 0x2f90: 0x0001, 0x2f91: 0x0001, 0x2f92: 0x0001, 0x2f93: 0x0001, 0x2f94: 0x0001, 0x2f95: 0x0001, 0x2f96: 0x0001, 0x2f97: 0x0001, 0x2f98: 0x0001, 0x2f99: 0x0001, 0x2f9a: 0x0001, 0x2f9b: 0x0001, 0x2f9c: 0x0001, 0x2f9d: 0x0001, 0x2f9e: 0x0001, 0x2f9f: 0x0001, 0x2fad: 0x0001, 0x2fae: 0x0001, 0x2faf: 0x0001, 0x2fb0: 0x0001, 0x2fb1: 0x0001, 0x2fb2: 0x0001, 0x2fb3: 0x0001, 0x2fb4: 0x0001, 0x2fb5: 0x0001, 0x2fb6: 0x0001, 0x2fb7: 0x0001, 0x2fb8: 0x0001, 0x2fb9: 0x0001, 0x2fba: 0x0001, 0x2fbb: 0x0001, 0x2fbc: 0x0001, 0x2fbd: 0x0001, 0x2fbe: 0x0001, 0x2fbf: 0x0001, // Block 0xbf, offset 0x2fc0 0x2fc0: 0x0001, 0x2fc1: 0x0001, 0x2fc2: 0x0001, 0x2fc3: 0x0001, 0x2fc4: 0x0001, 0x2fc5: 0x0001, 0x2fc6: 0x0001, 0x2fc7: 0x0001, 0x2fc8: 0x0001, 0x2fc9: 0x0001, 0x2fca: 0x0001, 0x2fd0: 0x0001, 0x2fd1: 0x0001, 0x2fd2: 0x0001, 0x2fd3: 0x0001, 0x2fd4: 0x0001, 0x2fd5: 0x0001, 0x2fd6: 0x0001, 0x2fd7: 0x0001, 0x2fd8: 0x0001, 0x2fd9: 0x0001, 0x2fda: 0x0001, 0x2fdb: 0x0001, 0x2fdc: 0x0001, 0x2fdd: 0x0001, 0x2fde: 0x0001, 0x2fdf: 0x0001, 0x2fe0: 0x0001, 0x2fe1: 0x0001, 0x2fe2: 0x0001, 0x2fe3: 0x0001, 0x2fe4: 0x0001, 0x2fe5: 0x0001, 0x2fe6: 0x0001, 0x2fe7: 0x0001, 0x2fe8: 0x0001, 0x2fe9: 0x0001, 0x2fea: 0x0001, 0x2feb: 0x0001, 0x2fec: 0x0001, 0x2fed: 0x0001, 0x2fee: 0x0001, 0x2fef: 0x0001, 0x2ff0: 0x0001, 0x2ff1: 0x0001, 0x2ff2: 0x0001, 0x2ff3: 0x0001, 0x2ff4: 0x0001, 0x2ff5: 0x0001, 0x2ff6: 0x0010, 0x2ff7: 0x0010, 0x2ff8: 0x0010, 0x2ff9: 0x0010, 0x2ffa: 0x0010, // Block 0xc0, offset 0x3000 0x3000: 0x0001, 0x3001: 0x0001, 0x3002: 0x0001, 0x3003: 0x0001, 0x3004: 0x0001, 0x3005: 0x0001, 0x3006: 0x0001, 0x3007: 0x0001, 0x3008: 0x0001, 0x3009: 0x0001, 0x300a: 0x0001, 0x300b: 0x0001, 0x300c: 0x0001, 0x300d: 0x0001, 0x300e: 0x0001, 0x300f: 0x0001, 0x3010: 0x0001, 0x3011: 0x0001, 0x3012: 0x0001, 0x3013: 0x0001, 0x3014: 0x0001, 0x3015: 0x0001, 0x3016: 0x0001, 0x3017: 0x0001, 0x3018: 0x0001, 0x3019: 0x0001, 0x301a: 0x0001, 0x301b: 0x0001, 0x301c: 0x0001, 0x301d: 0x0001, 0x3020: 0x0001, 0x3021: 0x0001, 0x3022: 0x0001, 0x3023: 0x0001, 0x3024: 0x0001, 0x3025: 0x0001, 0x3026: 0x0001, 0x3027: 0x0001, 0x3028: 0x0001, 0x3029: 0x0001, 0x302a: 0x0001, 0x302b: 0x0001, 0x302c: 0x0001, 0x302d: 0x0001, 0x302e: 0x0001, 0x302f: 0x0001, 0x3030: 0x0001, 0x3031: 0x0001, 0x3032: 0x0001, 0x3033: 0x0001, 0x3034: 0x0001, 0x3035: 0x0001, 0x3036: 0x0001, 0x3037: 0x0001, 0x3038: 0x0001, 0x3039: 0x0001, 0x303a: 0x0001, 0x303b: 0x0001, 0x303c: 0x0001, 0x303d: 0x0001, 0x303e: 0x0001, 0x303f: 0x0001, // Block 0xc1, offset 0x3040 0x3040: 0x0001, 0x3041: 0x0001, 0x3042: 0x0001, 0x3043: 0x0001, 0x3048: 0x0001, 0x3049: 0x0001, 0x304a: 0x0001, 0x304b: 0x0001, 0x304c: 0x0001, 0x304d: 0x0001, 0x304e: 0x0001, 0x304f: 0x0001, 0x3051: 0x0001, 0x3052: 0x0001, 0x3053: 0x0001, 0x3054: 0x0001, 0x3055: 0x0001, // Block 0xc2, offset 0x3080 0x3080: 0x0001, 0x3081: 0x0001, 0x3082: 0x0001, 0x3083: 0x0001, 0x3084: 0x0001, 0x3085: 0x0001, 0x3086: 0x0001, 0x3087: 0x0001, 0x3088: 0x0001, 0x3089: 0x0001, 0x308a: 0x0001, 0x308b: 0x0001, 0x308c: 0x0001, 0x308d: 0x0001, 0x308e: 0x0001, 0x308f: 0x0001, 0x3090: 0x0001, 0x3091: 0x0001, 0x3092: 0x0001, 0x3093: 0x0001, 0x3094: 0x0001, 0x3095: 0x0001, 0x3096: 0x0001, 0x3097: 0x0001, 0x3098: 0x0001, 0x3099: 0x0001, 0x309a: 0x0001, 0x309b: 0x0001, 0x309c: 0x0001, 0x309d: 0x0001, 0x30a0: 0x8000, 0x30a1: 0x8000, 0x30a2: 0x8000, 0x30a3: 0x8000, 0x30a4: 0x8000, 0x30a5: 0x8000, 0x30a6: 0x8000, 0x30a7: 0x8000, 0x30a8: 0x8000, 0x30a9: 0x8000, 0x30b0: 0x0001, 0x30b1: 0x0001, 0x30b2: 0x0001, 0x30b3: 0x0001, 0x30b4: 0x0001, 0x30b5: 0x0001, 0x30b6: 0x0001, 0x30b7: 0x0001, 0x30b8: 0x0001, 0x30b9: 0x0001, 0x30ba: 0x0001, 0x30bb: 0x0001, 0x30bc: 0x0001, 0x30bd: 0x0001, 0x30be: 0x0001, 0x30bf: 0x0001, // Block 0xc3, offset 0x30c0 0x30c0: 0x0001, 0x30c1: 0x0001, 0x30c2: 0x0001, 0x30c3: 0x0001, 0x30c4: 0x0001, 0x30c5: 0x0001, 0x30c6: 0x0001, 0x30c7: 0x0001, 0x30c8: 0x0001, 0x30c9: 0x0001, 0x30ca: 0x0001, 0x30cb: 0x0001, 0x30cc: 0x0001, 0x30cd: 0x0001, 0x30ce: 0x0001, 0x30cf: 0x0001, 0x30d0: 0x0001, 0x30d1: 0x0001, 0x30d2: 0x0001, 0x30d3: 0x0001, 0x30d8: 0x0001, 0x30d9: 0x0001, 0x30da: 0x0001, 0x30db: 0x0001, 0x30dc: 0x0001, 0x30dd: 0x0001, 0x30de: 0x0001, 0x30df: 0x0001, 0x30e0: 0x0001, 0x30e1: 0x0001, 0x30e2: 0x0001, 0x30e3: 0x0001, 0x30e4: 0x0001, 0x30e5: 0x0001, 0x30e6: 0x0001, 0x30e7: 0x0001, 0x30e8: 0x0001, 0x30e9: 0x0001, 0x30ea: 0x0001, 0x30eb: 0x0001, 0x30ec: 0x0001, 0x30ed: 0x0001, 0x30ee: 0x0001, 0x30ef: 0x0001, 0x30f0: 0x0001, 0x30f1: 0x0001, 0x30f2: 0x0001, 0x30f3: 0x0001, 0x30f4: 0x0001, 0x30f5: 0x0001, 0x30f6: 0x0001, 0x30f7: 0x0001, 0x30f8: 0x0001, 0x30f9: 0x0001, 0x30fa: 0x0001, 0x30fb: 0x0001, // Block 0xc4, offset 0x3100 0x3100: 0x0001, 0x3101: 0x0001, 0x3102: 0x0001, 0x3103: 0x0001, 0x3104: 0x0001, 0x3105: 0x0001, 0x3106: 0x0001, 0x3107: 0x0001, 0x3108: 0x0001, 0x3109: 0x0001, 0x310a: 0x0001, 0x310b: 0x0001, 0x310c: 0x0001, 0x310d: 0x0001, 0x310e: 0x0001, 0x310f: 0x0001, 0x3110: 0x0001, 0x3111: 0x0001, 0x3112: 0x0001, 0x3113: 0x0001, 0x3114: 0x0001, 0x3115: 0x0001, 0x3116: 0x0001, 0x3117: 0x0001, 0x3118: 0x0001, 0x3119: 0x0001, 0x311a: 0x0001, 0x311b: 0x0001, 0x311c: 0x0001, 0x311d: 0x0001, 0x311e: 0x0001, 0x311f: 0x0001, 0x3120: 0x0001, 0x3121: 0x0001, 0x3122: 0x0001, 0x3123: 0x0001, 0x3124: 0x0001, 0x3125: 0x0001, 0x3126: 0x0001, 0x3127: 0x0001, 0x3130: 0x0001, 0x3131: 0x0001, 0x3132: 0x0001, 0x3133: 0x0001, 0x3134: 0x0001, 0x3135: 0x0001, 0x3136: 0x0001, 0x3137: 0x0001, 0x3138: 0x0001, 0x3139: 0x0001, 0x313a: 0x0001, 0x313b: 0x0001, 0x313c: 0x0001, 0x313d: 0x0001, 0x313e: 0x0001, 0x313f: 0x0001, // Block 0xc5, offset 0x3140 0x3140: 0x0001, 0x3141: 0x0001, 0x3142: 0x0001, 0x3143: 0x0001, 0x3144: 0x0001, 0x3145: 0x0001, 0x3146: 0x0001, 0x3147: 0x0001, 0x3148: 0x0001, 0x3149: 0x0001, 0x314a: 0x0001, 0x314b: 0x0001, 0x314c: 0x0001, 0x314d: 0x0001, 0x314e: 0x0001, 0x314f: 0x0001, 0x3150: 0x0001, 0x3151: 0x0001, 0x3152: 0x0001, 0x3153: 0x0001, 0x3154: 0x0001, 0x3155: 0x0001, 0x3156: 0x0001, 0x3157: 0x0001, 0x3158: 0x0001, 0x3159: 0x0001, 0x315a: 0x0001, 0x315b: 0x0001, 0x315c: 0x0001, 0x315d: 0x0001, 0x315e: 0x0001, 0x315f: 0x0001, 0x3160: 0x0001, 0x3161: 0x0001, 0x3162: 0x0001, 0x3163: 0x0001, 0x3170: 0x0001, 0x3171: 0x0001, 0x3172: 0x0001, 0x3173: 0x0001, 0x3174: 0x0001, 0x3175: 0x0001, 0x3176: 0x0001, 0x3177: 0x0001, 0x3178: 0x0001, 0x3179: 0x0001, 0x317a: 0x0001, 0x317c: 0x0001, 0x317d: 0x0001, 0x317e: 0x0001, 0x317f: 0x0001, // Block 0xc6, offset 0x3180 0x3180: 0x0001, 0x3181: 0x0001, 0x3182: 0x0001, 0x3183: 0x0001, 0x3184: 0x0001, 0x3185: 0x0001, 0x3186: 0x0001, 0x3187: 0x0001, 0x3188: 0x0001, 0x3189: 0x0001, 0x318a: 0x0001, 0x318c: 0x0001, 0x318d: 0x0001, 0x318e: 0x0001, 0x318f: 0x0001, 0x3190: 0x0001, 0x3191: 0x0001, 0x3192: 0x0001, 0x3194: 0x0001, 0x3195: 0x0001, 0x3197: 0x0001, 0x3198: 0x0001, 0x3199: 0x0001, 0x319a: 0x0001, 0x319b: 0x0001, 0x319c: 0x0001, 0x319d: 0x0001, 0x319e: 0x0001, 0x319f: 0x0001, 0x31a0: 0x0001, 0x31a1: 0x0001, 0x31a3: 0x0001, 0x31a4: 0x0001, 0x31a5: 0x0001, 0x31a6: 0x0001, 0x31a7: 0x0001, 0x31a8: 0x0001, 0x31a9: 0x0001, 0x31aa: 0x0001, 0x31ab: 0x0001, 0x31ac: 0x0001, 0x31ad: 0x0001, 0x31ae: 0x0001, 0x31af: 0x0001, 0x31b0: 0x0001, 0x31b1: 0x0001, 0x31b3: 0x0001, 0x31b4: 0x0001, 0x31b5: 0x0001, 0x31b6: 0x0001, 0x31b7: 0x0001, 0x31b8: 0x0001, 0x31b9: 0x0001, 0x31bb: 0x0001, 0x31bc: 0x0001, // Block 0xc7, offset 0x31c0 0x31c0: 0x0001, 0x31c1: 0x0001, 0x31c2: 0x0001, 0x31c3: 0x0001, 0x31c4: 0x0001, 0x31c5: 0x0001, 0x31c6: 0x0001, 0x31c7: 0x0001, 0x31c8: 0x0001, 0x31c9: 0x0001, 0x31ca: 0x0001, 0x31cb: 0x0001, 0x31cc: 0x0001, 0x31cd: 0x0001, 0x31ce: 0x0001, 0x31cf: 0x0001, 0x31d0: 0x0001, 0x31d1: 0x0001, 0x31d2: 0x0001, 0x31d3: 0x0001, 0x31d4: 0x0001, 0x31d5: 0x0001, 0x31d6: 0x0001, 0x31d7: 0x0001, 0x31d8: 0x0001, 0x31d9: 0x0001, 0x31da: 0x0001, 0x31db: 0x0001, 0x31dc: 0x0001, 0x31dd: 0x0001, 0x31de: 0x0001, 0x31df: 0x0001, 0x31e0: 0x0001, 0x31e1: 0x0001, 0x31e2: 0x0001, 0x31e3: 0x0001, 0x31e4: 0x0001, 0x31e5: 0x0001, 0x31e6: 0x0001, 0x31e7: 0x0001, 0x31e8: 0x0001, 0x31e9: 0x0001, 0x31ea: 0x0001, 0x31eb: 0x0001, 0x31ec: 0x0001, 0x31ed: 0x0001, 0x31ee: 0x0001, 0x31ef: 0x0001, 0x31f0: 0x0001, 0x31f1: 0x0001, 0x31f2: 0x0001, 0x31f3: 0x0001, 0x31f4: 0x0001, 0x31f5: 0x0001, 0x31f6: 0x0001, // Block 0xc8, offset 0x3200 0x3200: 0x0001, 0x3201: 0x0001, 0x3202: 0x0001, 0x3203: 0x0001, 0x3204: 0x0001, 0x3205: 0x0001, 0x3206: 0x0001, 0x3207: 0x0001, 0x3208: 0x0001, 0x3209: 0x0001, 0x320a: 0x0001, 0x320b: 0x0001, 0x320c: 0x0001, 0x320d: 0x0001, 0x320e: 0x0001, 0x320f: 0x0001, 0x3210: 0x0001, 0x3211: 0x0001, 0x3212: 0x0001, 0x3213: 0x0001, 0x3214: 0x0001, 0x3215: 0x0001, 0x3220: 0x0001, 0x3221: 0x0001, 0x3222: 0x0001, 0x3223: 0x0001, 0x3224: 0x0001, 0x3225: 0x0001, 0x3226: 0x0001, 0x3227: 0x0001, // Block 0xc9, offset 0x3240 0x3240: 0x0001, 0x3241: 0x0001, 0x3242: 0x0001, 0x3243: 0x0001, 0x3244: 0x0001, 0x3245: 0x0001, 0x3247: 0x0001, 0x3248: 0x0001, 0x3249: 0x0001, 0x324a: 0x0001, 0x324b: 0x0001, 0x324c: 0x0001, 0x324d: 0x0001, 0x324e: 0x0001, 0x324f: 0x0001, 0x3250: 0x0001, 0x3251: 0x0001, 0x3252: 0x0001, 0x3253: 0x0001, 0x3254: 0x0001, 0x3255: 0x0001, 0x3256: 0x0001, 0x3257: 0x0001, 0x3258: 0x0001, 0x3259: 0x0001, 0x325a: 0x0001, 0x325b: 0x0001, 0x325c: 0x0001, 0x325d: 0x0001, 0x325e: 0x0001, 0x325f: 0x0001, 0x3260: 0x0001, 0x3261: 0x0001, 0x3262: 0x0001, 0x3263: 0x0001, 0x3264: 0x0001, 0x3265: 0x0001, 0x3266: 0x0001, 0x3267: 0x0001, 0x3268: 0x0001, 0x3269: 0x0001, 0x326a: 0x0001, 0x326b: 0x0001, 0x326c: 0x0001, 0x326d: 0x0001, 0x326e: 0x0001, 0x326f: 0x0001, 0x3270: 0x0001, 0x3272: 0x0001, 0x3273: 0x0001, 0x3274: 0x0001, 0x3275: 0x0001, 0x3276: 0x0001, 0x3277: 0x0001, 0x3278: 0x0001, 0x3279: 0x0001, 0x327a: 0x0001, // Block 0xca, offset 0x3280 0x3280: 0x0001, 0x3281: 0x0001, 0x3282: 0x0001, 0x3283: 0x0001, 0x3284: 0x0001, 0x3285: 0x0001, 0x3288: 0x0001, 0x328a: 0x0001, 0x328b: 0x0001, 0x328c: 0x0001, 0x328d: 0x0001, 0x328e: 0x0001, 0x328f: 0x0001, 0x3290: 0x0001, 0x3291: 0x0001, 0x3292: 0x0001, 0x3293: 0x0001, 0x3294: 0x0001, 0x3295: 0x0001, 0x3296: 0x0001, 0x3297: 0x0001, 0x3298: 0x0001, 0x3299: 0x0001, 0x329a: 0x0001, 0x329b: 0x0001, 0x329c: 0x0001, 0x329d: 0x0001, 0x329e: 0x0001, 0x329f: 0x0001, 0x32a0: 0x0001, 0x32a1: 0x0001, 0x32a2: 0x0001, 0x32a3: 0x0001, 0x32a4: 0x0001, 0x32a5: 0x0001, 0x32a6: 0x0001, 0x32a7: 0x0001, 0x32a8: 0x0001, 0x32a9: 0x0001, 0x32aa: 0x0001, 0x32ab: 0x0001, 0x32ac: 0x0001, 0x32ad: 0x0001, 0x32ae: 0x0001, 0x32af: 0x0001, 0x32b0: 0x0001, 0x32b1: 0x0001, 0x32b2: 0x0001, 0x32b3: 0x0001, 0x32b4: 0x0001, 0x32b5: 0x0001, 0x32b7: 0x0001, 0x32b8: 0x0001, 0x32bc: 0x0001, 0x32bf: 0x0001, // Block 0xcb, offset 0x32c0 0x32c0: 0x0001, 0x32c1: 0x0001, 0x32c2: 0x0001, 0x32c3: 0x0001, 0x32c4: 0x0001, 0x32c5: 0x0001, 0x32c6: 0x0001, 0x32c7: 0x0001, 0x32c8: 0x0001, 0x32c9: 0x0001, 0x32ca: 0x0001, 0x32cb: 0x0001, 0x32cc: 0x0001, 0x32cd: 0x0001, 0x32ce: 0x0001, 0x32cf: 0x0001, 0x32d0: 0x0001, 0x32d1: 0x0001, 0x32d2: 0x0001, 0x32d3: 0x0001, 0x32d4: 0x0001, 0x32d5: 0x0001, 0x32e0: 0x0001, 0x32e1: 0x0001, 0x32e2: 0x0001, 0x32e3: 0x0001, 0x32e4: 0x0001, 0x32e5: 0x0001, 0x32e6: 0x0001, 0x32e7: 0x0001, 0x32e8: 0x0001, 0x32e9: 0x0001, 0x32ea: 0x0001, 0x32eb: 0x0001, 0x32ec: 0x0001, 0x32ed: 0x0001, 0x32ee: 0x0001, 0x32ef: 0x0001, 0x32f0: 0x0001, 0x32f1: 0x0001, 0x32f2: 0x0001, 0x32f3: 0x0001, 0x32f4: 0x0001, 0x32f5: 0x0001, 0x32f6: 0x0001, // Block 0xcc, offset 0x3300 0x3300: 0x0001, 0x3301: 0x0001, 0x3302: 0x0001, 0x3303: 0x0001, 0x3304: 0x0001, 0x3305: 0x0001, 0x3306: 0x0001, 0x3307: 0x0001, 0x3308: 0x0001, 0x3309: 0x0001, 0x330a: 0x0001, 0x330b: 0x0001, 0x330c: 0x0001, 0x330d: 0x0001, 0x330e: 0x0001, 0x330f: 0x0001, 0x3310: 0x0001, 0x3311: 0x0001, 0x3312: 0x0001, 0x3313: 0x0001, 0x3314: 0x0001, 0x3315: 0x0001, 0x3316: 0x0001, 0x3317: 0x0001, 0x3318: 0x0001, 0x3319: 0x0001, 0x331a: 0x0001, 0x331b: 0x0001, 0x331c: 0x0001, 0x331d: 0x0001, 0x331e: 0x0001, // Block 0xcd, offset 0x3340 0x3360: 0x0001, 0x3361: 0x0001, 0x3362: 0x0001, 0x3363: 0x0001, 0x3364: 0x0001, 0x3365: 0x0001, 0x3366: 0x0001, 0x3367: 0x0001, 0x3368: 0x0001, 0x3369: 0x0001, 0x336a: 0x0001, 0x336b: 0x0001, 0x336c: 0x0001, 0x336d: 0x0001, 0x336e: 0x0001, 0x336f: 0x0001, 0x3370: 0x0001, 0x3371: 0x0001, 0x3372: 0x0001, 0x3374: 0x0001, 0x3375: 0x0001, // Block 0xce, offset 0x3380 0x3380: 0x0001, 0x3381: 0x0001, 0x3382: 0x0001, 0x3383: 0x0001, 0x3384: 0x0001, 0x3385: 0x0001, 0x3386: 0x0001, 0x3387: 0x0001, 0x3388: 0x0001, 0x3389: 0x0001, 0x338a: 0x0001, 0x338b: 0x0001, 0x338c: 0x0001, 0x338d: 0x0001, 0x338e: 0x0001, 0x338f: 0x0001, 0x3390: 0x0001, 0x3391: 0x0001, 0x3392: 0x0001, 0x3393: 0x0001, 0x3394: 0x0001, 0x3395: 0x0001, 0x33a0: 0x0001, 0x33a1: 0x0001, 0x33a2: 0x0001, 0x33a3: 0x0001, 0x33a4: 0x0001, 0x33a5: 0x0001, 0x33a6: 0x0001, 0x33a7: 0x0001, 0x33a8: 0x0001, 0x33a9: 0x0001, 0x33aa: 0x0001, 0x33ab: 0x0001, 0x33ac: 0x0001, 0x33ad: 0x0001, 0x33ae: 0x0001, 0x33af: 0x0001, 0x33b0: 0x0001, 0x33b1: 0x0001, 0x33b2: 0x0001, 0x33b3: 0x0001, 0x33b4: 0x0001, 0x33b5: 0x0001, 0x33b6: 0x0001, 0x33b7: 0x0001, 0x33b8: 0x0001, 0x33b9: 0x0001, // Block 0xcf, offset 0x33c0 0x33c0: 0x0001, 0x33c1: 0x0001, 0x33c2: 0x0001, 0x33c3: 0x0001, 0x33c4: 0x0001, 0x33c5: 0x0001, 0x33c6: 0x0001, 0x33c7: 0x0001, 0x33c8: 0x0001, 0x33c9: 0x0001, 0x33ca: 0x0001, 0x33cb: 0x0001, 0x33cc: 0x0001, 0x33cd: 0x0001, 0x33ce: 0x0001, 0x33cf: 0x0001, 0x33d0: 0x0001, 0x33d1: 0x0001, 0x33d2: 0x0001, 0x33d3: 0x0001, 0x33d4: 0x0001, 0x33d5: 0x0001, 0x33d6: 0x0001, 0x33d7: 0x0001, 0x33d8: 0x0001, 0x33d9: 0x0001, // Block 0xd0, offset 0x3400 0x3400: 0x0001, 0x3401: 0x0001, 0x3402: 0x0001, 0x3403: 0x0001, 0x3404: 0x0001, 0x3405: 0x0001, 0x3406: 0x0001, 0x3407: 0x0001, 0x3408: 0x0001, 0x3409: 0x0001, 0x340a: 0x0001, 0x340b: 0x0001, 0x340c: 0x0001, 0x340d: 0x0001, 0x340e: 0x0001, 0x340f: 0x0001, 0x3410: 0x0001, 0x3411: 0x0001, 0x3412: 0x0001, 0x3413: 0x0001, 0x3414: 0x0001, 0x3415: 0x0001, 0x3416: 0x0001, 0x3417: 0x0001, 0x3418: 0x0001, 0x3419: 0x0001, 0x341a: 0x0001, 0x341b: 0x0001, 0x341c: 0x0001, 0x341d: 0x0001, 0x341e: 0x0001, 0x341f: 0x0001, 0x3420: 0x0001, 0x3421: 0x0001, 0x3422: 0x0001, 0x3423: 0x0001, 0x3424: 0x0001, 0x3425: 0x0001, 0x3426: 0x0001, 0x3427: 0x0001, 0x3428: 0x0001, 0x3429: 0x0001, 0x342a: 0x0001, 0x342b: 0x0001, 0x342c: 0x0001, 0x342d: 0x0001, 0x342e: 0x0001, 0x342f: 0x0001, 0x3430: 0x0001, 0x3431: 0x0001, 0x3432: 0x0001, 0x3433: 0x0001, 0x3434: 0x0001, 0x3435: 0x0001, 0x3436: 0x0001, 0x3437: 0x0001, 0x343e: 0x0001, 0x343f: 0x0001, // Block 0xd1, offset 0x3440 0x3440: 0x0001, 0x3441: 0x0010, 0x3442: 0x0010, 0x3443: 0x0010, 0x3445: 0x0010, 0x3446: 0x0010, 0x344c: 0x0010, 0x344d: 0x0010, 0x344e: 0x0010, 0x344f: 0x0010, 0x3450: 0x0001, 0x3451: 0x0001, 0x3452: 0x0001, 0x3453: 0x0001, 0x3455: 0x0001, 0x3456: 0x0001, 0x3457: 0x0001, 0x3459: 0x0001, 0x345a: 0x0001, 0x345b: 0x0001, 0x345c: 0x0001, 0x345d: 0x0001, 0x345e: 0x0001, 0x345f: 0x0001, 0x3460: 0x0001, 0x3461: 0x0001, 0x3462: 0x0001, 0x3463: 0x0001, 0x3464: 0x0001, 0x3465: 0x0001, 0x3466: 0x0001, 0x3467: 0x0001, 0x3468: 0x0001, 0x3469: 0x0001, 0x346a: 0x0001, 0x346b: 0x0001, 0x346c: 0x0001, 0x346d: 0x0001, 0x346e: 0x0001, 0x346f: 0x0001, 0x3470: 0x0001, 0x3471: 0x0001, 0x3472: 0x0001, 0x3473: 0x0001, 0x3474: 0x0001, 0x3475: 0x0001, 0x3478: 0x0010, 0x3479: 0x0010, 0x347a: 0x0010, 0x347f: 0x0010, // Block 0xd2, offset 0x3480 0x34a0: 0x0001, 0x34a1: 0x0001, 0x34a2: 0x0001, 0x34a3: 0x0001, 0x34a4: 0x0001, 0x34a5: 0x0001, 0x34a6: 0x0001, 0x34a7: 0x0001, 0x34a8: 0x0001, 0x34a9: 0x0001, 0x34aa: 0x0001, 0x34ab: 0x0001, 0x34ac: 0x0001, 0x34ad: 0x0001, 0x34ae: 0x0001, 0x34af: 0x0001, 0x34b0: 0x0001, 0x34b1: 0x0001, 0x34b2: 0x0001, 0x34b3: 0x0001, 0x34b4: 0x0001, 0x34b5: 0x0001, 0x34b6: 0x0001, 0x34b7: 0x0001, 0x34b8: 0x0001, 0x34b9: 0x0001, 0x34ba: 0x0001, 0x34bb: 0x0001, 0x34bc: 0x0001, // Block 0xd3, offset 0x34c0 0x34c0: 0x0001, 0x34c1: 0x0001, 0x34c2: 0x0001, 0x34c3: 0x0001, 0x34c4: 0x0001, 0x34c5: 0x0001, 0x34c6: 0x0001, 0x34c7: 0x0001, 0x34c8: 0x0001, 0x34c9: 0x0001, 0x34ca: 0x0001, 0x34cb: 0x0001, 0x34cc: 0x0001, 0x34cd: 0x0001, 0x34ce: 0x0001, 0x34cf: 0x0001, 0x34d0: 0x0001, 0x34d1: 0x0001, 0x34d2: 0x0001, 0x34d3: 0x0001, 0x34d4: 0x0001, 0x34d5: 0x0001, 0x34d6: 0x0001, 0x34d7: 0x0001, 0x34d8: 0x0001, 0x34d9: 0x0001, 0x34da: 0x0001, 0x34db: 0x0001, 0x34dc: 0x0001, // Block 0xd4, offset 0x3500 0x3500: 0x0001, 0x3501: 0x0001, 0x3502: 0x0001, 0x3503: 0x0001, 0x3504: 0x0001, 0x3505: 0x0001, 0x3506: 0x0001, 0x3507: 0x0001, 0x3509: 0x0001, 0x350a: 0x0001, 0x350b: 0x0001, 0x350c: 0x0001, 0x350d: 0x0001, 0x350e: 0x0001, 0x350f: 0x0001, 0x3510: 0x0001, 0x3511: 0x0001, 0x3512: 0x0001, 0x3513: 0x0001, 0x3514: 0x0001, 0x3515: 0x0001, 0x3516: 0x0001, 0x3517: 0x0001, 0x3518: 0x0001, 0x3519: 0x0001, 0x351a: 0x0001, 0x351b: 0x0001, 0x351c: 0x0001, 0x351d: 0x0001, 0x351e: 0x0001, 0x351f: 0x0001, 0x3520: 0x0001, 0x3521: 0x0001, 0x3522: 0x0001, 0x3523: 0x0001, 0x3524: 0x0001, 0x3525: 0x0010, 0x3526: 0x0010, // Block 0xd5, offset 0x3540 0x3540: 0x0001, 0x3541: 0x0001, 0x3542: 0x0001, 0x3543: 0x0001, 0x3544: 0x0001, 0x3545: 0x0001, 0x3546: 0x0001, 0x3547: 0x0001, 0x3548: 0x0001, 0x3549: 0x0001, 0x354a: 0x0001, 0x354b: 0x0001, 0x354c: 0x0001, 0x354d: 0x0001, 0x354e: 0x0001, 0x354f: 0x0001, 0x3550: 0x0001, 0x3551: 0x0001, 0x3552: 0x0001, 0x3553: 0x0001, 0x3554: 0x0001, 0x3555: 0x0001, 0x3560: 0x0001, 0x3561: 0x0001, 0x3562: 0x0001, 0x3563: 0x0001, 0x3564: 0x0001, 0x3565: 0x0001, 0x3566: 0x0001, 0x3567: 0x0001, 0x3568: 0x0001, 0x3569: 0x0001, 0x356a: 0x0001, 0x356b: 0x0001, 0x356c: 0x0001, 0x356d: 0x0001, 0x356e: 0x0001, 0x356f: 0x0001, 0x3570: 0x0001, 0x3571: 0x0001, 0x3572: 0x0001, // Block 0xd6, offset 0x3580 0x3580: 0x0001, 0x3581: 0x0001, 0x3582: 0x0001, 0x3583: 0x0001, 0x3584: 0x0001, 0x3585: 0x0001, 0x3586: 0x0001, 0x3587: 0x0001, 0x3588: 0x0001, 0x3589: 0x0001, 0x358a: 0x0001, 0x358b: 0x0001, 0x358c: 0x0001, 0x358d: 0x0001, 0x358e: 0x0001, 0x358f: 0x0001, 0x3590: 0x0001, 0x3591: 0x0001, // Block 0xd7, offset 0x35c0 0x35c0: 0x0001, 0x35c1: 0x0001, 0x35c2: 0x0001, 0x35c3: 0x0001, 0x35c4: 0x0001, 0x35c5: 0x0001, 0x35c6: 0x0001, 0x35c7: 0x0001, 0x35c8: 0x0001, // Block 0xd8, offset 0x3600 0x3600: 0x0001, 0x3601: 0x0001, 0x3602: 0x0001, 0x3603: 0x0001, 0x3604: 0x0001, 0x3605: 0x0001, 0x3606: 0x0001, 0x3607: 0x0001, 0x3608: 0x0001, 0x3609: 0x0001, 0x360a: 0x0001, 0x360b: 0x0001, 0x360c: 0x0001, 0x360d: 0x0001, 0x360e: 0x0001, 0x360f: 0x0001, 0x3610: 0x0001, 0x3611: 0x0001, 0x3612: 0x0001, 0x3613: 0x0001, 0x3614: 0x0001, 0x3615: 0x0001, 0x3616: 0x0001, 0x3617: 0x0001, 0x3618: 0x0001, 0x3619: 0x0001, 0x361a: 0x0001, 0x361b: 0x0001, 0x361c: 0x0001, 0x361d: 0x0001, 0x361e: 0x0001, 0x361f: 0x0001, 0x3620: 0x0001, 0x3621: 0x0001, 0x3622: 0x0001, 0x3623: 0x0001, 0x3624: 0x0001, 0x3625: 0x0001, 0x3626: 0x0001, 0x3627: 0x0001, 0x3628: 0x0001, 0x3629: 0x0001, 0x362a: 0x0001, 0x362b: 0x0001, 0x362c: 0x0001, 0x362d: 0x0001, 0x362e: 0x0001, 0x362f: 0x0001, 0x3630: 0x0001, 0x3631: 0x0001, 0x3632: 0x0001, // Block 0xd9, offset 0x3640 0x3640: 0x0001, 0x3641: 0x0001, 0x3642: 0x0001, 0x3643: 0x0001, 0x3644: 0x0001, 0x3645: 0x0001, 0x3646: 0x0001, 0x3647: 0x0001, 0x3648: 0x0001, 0x3649: 0x0001, 0x364a: 0x0001, 0x364b: 0x0001, 0x364c: 0x0001, 0x364d: 0x0001, 0x364e: 0x0001, 0x364f: 0x0001, 0x3650: 0x0001, 0x3651: 0x0001, 0x3652: 0x0001, 0x3653: 0x0001, 0x3654: 0x0001, 0x3655: 0x0001, 0x3656: 0x0001, 0x3657: 0x0001, 0x3658: 0x0001, 0x3659: 0x0001, 0x365a: 0x0001, 0x365b: 0x0001, 0x365c: 0x0001, 0x365d: 0x0001, 0x365e: 0x0001, 0x365f: 0x0001, 0x3660: 0x0001, 0x3661: 0x0001, 0x3662: 0x0001, 0x3663: 0x0001, 0x3664: 0x0010, 0x3665: 0x0010, 0x3666: 0x0010, 0x3667: 0x0010, 0x3670: 0x8000, 0x3671: 0x8000, 0x3672: 0x8000, 0x3673: 0x8000, 0x3674: 0x8000, 0x3675: 0x8000, 0x3676: 0x8000, 0x3677: 0x8000, 0x3678: 0x8000, 0x3679: 0x8000, // Block 0xda, offset 0x3680 0x3680: 0x8000, 0x3681: 0x8000, 0x3682: 0x8000, 0x3683: 0x8000, 0x3684: 0x8000, 0x3685: 0x8000, 0x3686: 0x8000, 0x3687: 0x8000, 0x3688: 0x8000, 0x3689: 0x8000, 0x368a: 0x0001, 0x368b: 0x0001, 0x368c: 0x0001, 0x368d: 0x0001, 0x368e: 0x0001, 0x368f: 0x0001, 0x3690: 0x0001, 0x3691: 0x0001, 0x3692: 0x0001, 0x3693: 0x0001, 0x3694: 0x0001, 0x3695: 0x0001, 0x3696: 0x0001, 0x3697: 0x0001, 0x3698: 0x0001, 0x3699: 0x0001, 0x369a: 0x0001, 0x369b: 0x0001, 0x369c: 0x0001, 0x369d: 0x0001, 0x369e: 0x0001, 0x369f: 0x0001, 0x36a0: 0x0001, 0x36a1: 0x0001, 0x36a2: 0x0001, 0x36a3: 0x0001, 0x36a4: 0x0001, 0x36a5: 0x0001, 0x36a9: 0x0010, 0x36aa: 0x0010, 0x36ab: 0x0010, 0x36ac: 0x0010, 0x36ad: 0x0010, 0x36af: 0x0001, 0x36b0: 0x0001, 0x36b1: 0x0001, 0x36b2: 0x0001, 0x36b3: 0x0001, 0x36b4: 0x0001, 0x36b5: 0x0001, 0x36b6: 0x0001, 0x36b7: 0x0001, 0x36b8: 0x0001, 0x36b9: 0x0001, 0x36ba: 0x0001, 0x36bb: 0x0001, 0x36bc: 0x0001, 0x36bd: 0x0001, 0x36be: 0x0001, 0x36bf: 0x0001, // Block 0xdb, offset 0x36c0 0x36c0: 0x0001, 0x36c1: 0x0001, 0x36c2: 0x0001, 0x36c3: 0x0001, 0x36c4: 0x0001, 0x36c5: 0x0001, // Block 0xdc, offset 0x3700 0x3700: 0x0001, 0x3701: 0x0001, 0x3702: 0x0001, 0x3703: 0x0001, 0x3704: 0x0001, 0x3705: 0x0001, 0x3706: 0x0001, 0x3707: 0x0001, 0x3708: 0x0001, 0x3709: 0x0001, 0x370a: 0x0001, 0x370b: 0x0001, 0x370c: 0x0001, 0x370d: 0x0001, 0x370e: 0x0001, 0x370f: 0x0001, 0x3710: 0x0001, 0x3711: 0x0001, 0x3712: 0x0001, 0x3713: 0x0001, 0x3714: 0x0001, 0x3715: 0x0001, 0x3716: 0x0001, 0x3717: 0x0001, 0x3718: 0x0001, 0x3719: 0x0001, 0x371a: 0x0001, 0x371b: 0x0001, 0x371c: 0x0001, 0x371d: 0x0001, 0x371e: 0x0001, 0x371f: 0x0001, 0x3720: 0x0001, 0x3721: 0x0001, 0x3722: 0x0001, 0x3723: 0x0001, 0x3724: 0x0001, 0x3725: 0x0001, 0x3726: 0x0001, 0x3727: 0x0001, 0x3728: 0x0001, 0x3729: 0x0001, 0x372b: 0x0010, 0x372c: 0x0010, 0x3730: 0x0001, 0x3731: 0x0001, // Block 0xdd, offset 0x3740 0x3742: 0x0001, 0x3743: 0x0001, 0x3744: 0x0001, 0x3745: 0x0001, 0x3746: 0x0001, 0x3747: 0x0001, 0x377a: 0x0010, 0x377b: 0x0010, 0x377c: 0x0010, 0x377d: 0x0010, 0x377e: 0x0010, 0x377f: 0x0010, // Block 0xde, offset 0x3780 0x3780: 0x0001, 0x3781: 0x0001, 0x3782: 0x0001, 0x3783: 0x0001, 0x3784: 0x0001, 0x3785: 0x0001, 0x3786: 0x0001, 0x3787: 0x0001, 0x3788: 0x0001, 0x3789: 0x0001, 0x378a: 0x0001, 0x378b: 0x0001, 0x378c: 0x0001, 0x378d: 0x0001, 0x378e: 0x0001, 0x378f: 0x0001, 0x3790: 0x0001, 0x3791: 0x0001, 0x3792: 0x0001, 0x3793: 0x0001, 0x3794: 0x0001, 0x3795: 0x0001, 0x3796: 0x0001, 0x3797: 0x0001, 0x3798: 0x0001, 0x3799: 0x0001, 0x379a: 0x0001, 0x379b: 0x0001, 0x379c: 0x0001, 0x37a7: 0x0001, 0x37b0: 0x0001, 0x37b1: 0x0001, 0x37b2: 0x0001, 0x37b3: 0x0001, 0x37b4: 0x0001, 0x37b5: 0x0001, 0x37b6: 0x0001, 0x37b7: 0x0001, 0x37b8: 0x0001, 0x37b9: 0x0001, 0x37ba: 0x0001, 0x37bb: 0x0001, 0x37bc: 0x0001, 0x37bd: 0x0001, 0x37be: 0x0001, 0x37bf: 0x0001, // Block 0xdf, offset 0x37c0 0x37c0: 0x0001, 0x37c1: 0x0001, 0x37c2: 0x0001, 0x37c3: 0x0001, 0x37c4: 0x0001, 0x37c5: 0x0001, 0x37c6: 0x0010, 0x37c7: 0x0010, 0x37c8: 0x0010, 0x37c9: 0x0010, 0x37ca: 0x0010, 0x37cb: 0x0010, 0x37cc: 0x0010, 0x37cd: 0x0010, 0x37ce: 0x0010, 0x37cf: 0x0010, 0x37d0: 0x0010, 0x37f0: 0x0001, 0x37f1: 0x0001, 0x37f2: 0x0001, 0x37f3: 0x0001, 0x37f4: 0x0001, 0x37f5: 0x0001, 0x37f6: 0x0001, 0x37f7: 0x0001, 0x37f8: 0x0001, 0x37f9: 0x0001, 0x37fa: 0x0001, 0x37fb: 0x0001, 0x37fc: 0x0001, 0x37fd: 0x0001, 0x37fe: 0x0001, 0x37ff: 0x0001, // Block 0xe0, offset 0x3800 0x3800: 0x0001, 0x3801: 0x0001, 0x3802: 0x0010, 0x3803: 0x0010, 0x3804: 0x0010, 0x3805: 0x0010, 0x3830: 0x0001, 0x3831: 0x0001, 0x3832: 0x0001, 0x3833: 0x0001, 0x3834: 0x0001, 0x3835: 0x0001, 0x3836: 0x0001, 0x3837: 0x0001, 0x3838: 0x0001, 0x3839: 0x0001, 0x383a: 0x0001, 0x383b: 0x0001, 0x383c: 0x0001, 0x383d: 0x0001, 0x383e: 0x0001, 0x383f: 0x0001, // Block 0xe1, offset 0x3840 0x3840: 0x0001, 0x3841: 0x0001, 0x3842: 0x0001, 0x3843: 0x0001, 0x3844: 0x0001, 0x3860: 0x0001, 0x3861: 0x0001, 0x3862: 0x0001, 0x3863: 0x0001, 0x3864: 0x0001, 0x3865: 0x0001, 0x3866: 0x0001, 0x3867: 0x0001, 0x3868: 0x0001, 0x3869: 0x0001, 0x386a: 0x0001, 0x386b: 0x0001, 0x386c: 0x0001, 0x386d: 0x0001, 0x386e: 0x0001, 0x386f: 0x0001, 0x3870: 0x0001, 0x3871: 0x0001, 0x3872: 0x0001, 0x3873: 0x0001, 0x3874: 0x0001, 0x3875: 0x0001, 0x3876: 0x0001, // Block 0xe2, offset 0x3880 0x3880: 0x0010, 0x3881: 0x0010, 0x3882: 0x0010, 0x3883: 0x0001, 0x3884: 0x0001, 0x3885: 0x0001, 0x3886: 0x0001, 0x3887: 0x0001, 0x3888: 0x0001, 0x3889: 0x0001, 0x388a: 0x0001, 0x388b: 0x0001, 0x388c: 0x0001, 0x388d: 0x0001, 0x388e: 0x0001, 0x388f: 0x0001, 0x3890: 0x0001, 0x3891: 0x0001, 0x3892: 0x0001, 0x3893: 0x0001, 0x3894: 0x0001, 0x3895: 0x0001, 0x3896: 0x0001, 0x3897: 0x0001, 0x3898: 0x0001, 0x3899: 0x0001, 0x389a: 0x0001, 0x389b: 0x0001, 0x389c: 0x0001, 0x389d: 0x0001, 0x389e: 0x0001, 0x389f: 0x0001, 0x38a0: 0x0001, 0x38a1: 0x0001, 0x38a2: 0x0001, 0x38a3: 0x0001, 0x38a4: 0x0001, 0x38a5: 0x0001, 0x38a6: 0x0001, 0x38a7: 0x0001, 0x38a8: 0x0001, 0x38a9: 0x0001, 0x38aa: 0x0001, 0x38ab: 0x0001, 0x38ac: 0x0001, 0x38ad: 0x0001, 0x38ae: 0x0001, 0x38af: 0x0001, 0x38b0: 0x0001, 0x38b1: 0x0001, 0x38b2: 0x0001, 0x38b3: 0x0001, 0x38b4: 0x0001, 0x38b5: 0x0001, 0x38b6: 0x0001, 0x38b7: 0x0001, 0x38b8: 0x0010, 0x38b9: 0x0010, 0x38ba: 0x0010, 0x38bb: 0x0010, 0x38bc: 0x0010, 0x38bd: 0x0010, 0x38be: 0x0010, 0x38bf: 0x0010, // Block 0xe3, offset 0x38c0 0x38c0: 0x0010, 0x38c1: 0x0010, 0x38c2: 0x0010, 0x38c3: 0x0010, 0x38c4: 0x0010, 0x38c5: 0x0010, 0x38c6: 0x0010, 0x38e6: 0x8000, 0x38e7: 0x8000, 0x38e8: 0x8000, 0x38e9: 0x8000, 0x38ea: 0x8000, 0x38eb: 0x8000, 0x38ec: 0x8000, 0x38ed: 0x8000, 0x38ee: 0x8000, 0x38ef: 0x8000, 0x38f0: 0x0010, 0x38f1: 0x0001, 0x38f2: 0x0001, 0x38f3: 0x0010, 0x38f4: 0x0010, 0x38f5: 0x0001, 0x38ff: 0x0010, // Block 0xe4, offset 0x3900 0x3900: 0x0010, 0x3901: 0x0010, 0x3902: 0x0010, 0x3903: 0x0001, 0x3904: 0x0001, 0x3905: 0x0001, 0x3906: 0x0001, 0x3907: 0x0001, 0x3908: 0x0001, 0x3909: 0x0001, 0x390a: 0x0001, 0x390b: 0x0001, 0x390c: 0x0001, 0x390d: 0x0001, 0x390e: 0x0001, 0x390f: 0x0001, 0x3910: 0x0001, 0x3911: 0x0001, 0x3912: 0x0001, 0x3913: 0x0001, 0x3914: 0x0001, 0x3915: 0x0001, 0x3916: 0x0001, 0x3917: 0x0001, 0x3918: 0x0001, 0x3919: 0x0001, 0x391a: 0x0001, 0x391b: 0x0001, 0x391c: 0x0001, 0x391d: 0x0001, 0x391e: 0x0001, 0x391f: 0x0001, 0x3920: 0x0001, 0x3921: 0x0001, 0x3922: 0x0001, 0x3923: 0x0001, 0x3924: 0x0001, 0x3925: 0x0001, 0x3926: 0x0001, 0x3927: 0x0001, 0x3928: 0x0001, 0x3929: 0x0001, 0x392a: 0x0001, 0x392b: 0x0001, 0x392c: 0x0001, 0x392d: 0x0001, 0x392e: 0x0001, 0x392f: 0x0001, 0x3930: 0x0010, 0x3931: 0x0010, 0x3932: 0x0010, 0x3933: 0x0010, 0x3934: 0x0010, 0x3935: 0x0010, 0x3936: 0x0010, 0x3937: 0x0010, 0x3938: 0x0010, 0x3939: 0x0010, 0x393a: 0x0010, 0x393d: 0x8000, // Block 0xe5, offset 0x3940 0x3942: 0x0010, 0x394d: 0x8000, 0x3950: 0x0001, 0x3951: 0x0001, 0x3952: 0x0001, 0x3953: 0x0001, 0x3954: 0x0001, 0x3955: 0x0001, 0x3956: 0x0001, 0x3957: 0x0001, 0x3958: 0x0001, 0x3959: 0x0001, 0x395a: 0x0001, 0x395b: 0x0001, 0x395c: 0x0001, 0x395d: 0x0001, 0x395e: 0x0001, 0x395f: 0x0001, 0x3960: 0x0001, 0x3961: 0x0001, 0x3962: 0x0001, 0x3963: 0x0001, 0x3964: 0x0001, 0x3965: 0x0001, 0x3966: 0x0001, 0x3967: 0x0001, 0x3968: 0x0001, 0x3970: 0x8000, 0x3971: 0x8000, 0x3972: 0x8000, 0x3973: 0x8000, 0x3974: 0x8000, 0x3975: 0x8000, 0x3976: 0x8000, 0x3977: 0x8000, 0x3978: 0x8000, 0x3979: 0x8000, // Block 0xe6, offset 0x3980 0x3980: 0x0010, 0x3981: 0x0010, 0x3982: 0x0010, 0x3983: 0x0001, 0x3984: 0x0001, 0x3985: 0x0001, 0x3986: 0x0001, 0x3987: 0x0001, 0x3988: 0x0001, 0x3989: 0x0001, 0x398a: 0x0001, 0x398b: 0x0001, 0x398c: 0x0001, 0x398d: 0x0001, 0x398e: 0x0001, 0x398f: 0x0001, 0x3990: 0x0001, 0x3991: 0x0001, 0x3992: 0x0001, 0x3993: 0x0001, 0x3994: 0x0001, 0x3995: 0x0001, 0x3996: 0x0001, 0x3997: 0x0001, 0x3998: 0x0001, 0x3999: 0x0001, 0x399a: 0x0001, 0x399b: 0x0001, 0x399c: 0x0001, 0x399d: 0x0001, 0x399e: 0x0001, 0x399f: 0x0001, 0x39a0: 0x0001, 0x39a1: 0x0001, 0x39a2: 0x0001, 0x39a3: 0x0001, 0x39a4: 0x0001, 0x39a5: 0x0001, 0x39a6: 0x0001, 0x39a7: 0x0010, 0x39a8: 0x0010, 0x39a9: 0x0010, 0x39aa: 0x0010, 0x39ab: 0x0010, 0x39ac: 0x0010, 0x39ad: 0x0010, 0x39ae: 0x0010, 0x39af: 0x0010, 0x39b0: 0x0010, 0x39b1: 0x0010, 0x39b2: 0x0010, 0x39b3: 0x0010, 0x39b4: 0x0010, 0x39b6: 0x8000, 0x39b7: 0x8000, 0x39b8: 0x8000, 0x39b9: 0x8000, 0x39ba: 0x8000, 0x39bb: 0x8000, 0x39bc: 0x8000, 0x39bd: 0x8000, 0x39be: 0x8000, 0x39bf: 0x8000, // Block 0xe7, offset 0x39c0 0x39c4: 0x0001, 0x39c5: 0x0010, 0x39c6: 0x0010, 0x39c7: 0x0001, 0x39d0: 0x0001, 0x39d1: 0x0001, 0x39d2: 0x0001, 0x39d3: 0x0001, 0x39d4: 0x0001, 0x39d5: 0x0001, 0x39d6: 0x0001, 0x39d7: 0x0001, 0x39d8: 0x0001, 0x39d9: 0x0001, 0x39da: 0x0001, 0x39db: 0x0001, 0x39dc: 0x0001, 0x39dd: 0x0001, 0x39de: 0x0001, 0x39df: 0x0001, 0x39e0: 0x0001, 0x39e1: 0x0001, 0x39e2: 0x0001, 0x39e3: 0x0001, 0x39e4: 0x0001, 0x39e5: 0x0001, 0x39e6: 0x0001, 0x39e7: 0x0001, 0x39e8: 0x0001, 0x39e9: 0x0001, 0x39ea: 0x0001, 0x39eb: 0x0001, 0x39ec: 0x0001, 0x39ed: 0x0001, 0x39ee: 0x0001, 0x39ef: 0x0001, 0x39f0: 0x0001, 0x39f1: 0x0001, 0x39f2: 0x0001, 0x39f3: 0x0010, 0x39f6: 0x0001, // Block 0xe8, offset 0x3a00 0x3a00: 0x0010, 0x3a01: 0x0010, 0x3a02: 0x0010, 0x3a03: 0x0001, 0x3a04: 0x0001, 0x3a05: 0x0001, 0x3a06: 0x0001, 0x3a07: 0x0001, 0x3a08: 0x0001, 0x3a09: 0x0001, 0x3a0a: 0x0001, 0x3a0b: 0x0001, 0x3a0c: 0x0001, 0x3a0d: 0x0001, 0x3a0e: 0x0001, 0x3a0f: 0x0001, 0x3a10: 0x0001, 0x3a11: 0x0001, 0x3a12: 0x0001, 0x3a13: 0x0001, 0x3a14: 0x0001, 0x3a15: 0x0001, 0x3a16: 0x0001, 0x3a17: 0x0001, 0x3a18: 0x0001, 0x3a19: 0x0001, 0x3a1a: 0x0001, 0x3a1b: 0x0001, 0x3a1c: 0x0001, 0x3a1d: 0x0001, 0x3a1e: 0x0001, 0x3a1f: 0x0001, 0x3a20: 0x0001, 0x3a21: 0x0001, 0x3a22: 0x0001, 0x3a23: 0x0001, 0x3a24: 0x0001, 0x3a25: 0x0001, 0x3a26: 0x0001, 0x3a27: 0x0001, 0x3a28: 0x0001, 0x3a29: 0x0001, 0x3a2a: 0x0001, 0x3a2b: 0x0001, 0x3a2c: 0x0001, 0x3a2d: 0x0001, 0x3a2e: 0x0001, 0x3a2f: 0x0001, 0x3a30: 0x0001, 0x3a31: 0x0001, 0x3a32: 0x0001, 0x3a33: 0x0010, 0x3a34: 0x0010, 0x3a35: 0x0010, 0x3a36: 0x0010, 0x3a37: 0x0010, 0x3a38: 0x0010, 0x3a39: 0x0010, 0x3a3a: 0x0010, 0x3a3b: 0x0010, 0x3a3c: 0x0010, 0x3a3d: 0x0010, 0x3a3e: 0x0010, 0x3a3f: 0x0010, // Block 0xe9, offset 0x3a40 0x3a40: 0x0010, 0x3a41: 0x0001, 0x3a42: 0x0001, 0x3a43: 0x0001, 0x3a44: 0x0001, 0x3a49: 0x0010, 0x3a4a: 0x0010, 0x3a4b: 0x0010, 0x3a4c: 0x0010, 0x3a4e: 0x0010, 0x3a4f: 0x0010, 0x3a50: 0x8000, 0x3a51: 0x8000, 0x3a52: 0x8000, 0x3a53: 0x8000, 0x3a54: 0x8000, 0x3a55: 0x8000, 0x3a56: 0x8000, 0x3a57: 0x8000, 0x3a58: 0x8000, 0x3a59: 0x8000, 0x3a5a: 0x0001, 0x3a5c: 0x0001, // Block 0xea, offset 0x3a80 0x3a80: 0x0001, 0x3a81: 0x0001, 0x3a82: 0x0001, 0x3a83: 0x0001, 0x3a84: 0x0001, 0x3a85: 0x0001, 0x3a86: 0x0001, 0x3a87: 0x0001, 0x3a88: 0x0001, 0x3a89: 0x0001, 0x3a8a: 0x0001, 0x3a8b: 0x0001, 0x3a8c: 0x0001, 0x3a8d: 0x0001, 0x3a8e: 0x0001, 0x3a8f: 0x0001, 0x3a90: 0x0001, 0x3a91: 0x0001, 0x3a93: 0x0001, 0x3a94: 0x0001, 0x3a95: 0x0001, 0x3a96: 0x0001, 0x3a97: 0x0001, 0x3a98: 0x0001, 0x3a99: 0x0001, 0x3a9a: 0x0001, 0x3a9b: 0x0001, 0x3a9c: 0x0001, 0x3a9d: 0x0001, 0x3a9e: 0x0001, 0x3a9f: 0x0001, 0x3aa0: 0x0001, 0x3aa1: 0x0001, 0x3aa2: 0x0001, 0x3aa3: 0x0001, 0x3aa4: 0x0001, 0x3aa5: 0x0001, 0x3aa6: 0x0001, 0x3aa7: 0x0001, 0x3aa8: 0x0001, 0x3aa9: 0x0001, 0x3aaa: 0x0001, 0x3aab: 0x0001, 0x3aac: 0x0010, 0x3aad: 0x0010, 0x3aae: 0x0010, 0x3aaf: 0x0010, 0x3ab0: 0x0010, 0x3ab1: 0x0010, 0x3ab2: 0x0010, 0x3ab3: 0x0010, 0x3ab4: 0x0010, 0x3ab5: 0x0010, 0x3ab6: 0x0010, 0x3ab7: 0x0010, 0x3abe: 0x0010, 0x3abf: 0x0001, // Block 0xeb, offset 0x3ac0 0x3ac0: 0x0001, 0x3ac1: 0x0010, // Block 0xec, offset 0x3b00 0x3b00: 0x0001, 0x3b01: 0x0001, 0x3b02: 0x0001, 0x3b03: 0x0001, 0x3b04: 0x0001, 0x3b05: 0x0001, 0x3b06: 0x0001, 0x3b08: 0x0001, 0x3b0a: 0x0001, 0x3b0b: 0x0001, 0x3b0c: 0x0001, 0x3b0d: 0x0001, 0x3b0f: 0x0001, 0x3b10: 0x0001, 0x3b11: 0x0001, 0x3b12: 0x0001, 0x3b13: 0x0001, 0x3b14: 0x0001, 0x3b15: 0x0001, 0x3b16: 0x0001, 0x3b17: 0x0001, 0x3b18: 0x0001, 0x3b19: 0x0001, 0x3b1a: 0x0001, 0x3b1b: 0x0001, 0x3b1c: 0x0001, 0x3b1d: 0x0001, 0x3b1f: 0x0001, 0x3b20: 0x0001, 0x3b21: 0x0001, 0x3b22: 0x0001, 0x3b23: 0x0001, 0x3b24: 0x0001, 0x3b25: 0x0001, 0x3b26: 0x0001, 0x3b27: 0x0001, 0x3b28: 0x0001, 0x3b30: 0x0001, 0x3b31: 0x0001, 0x3b32: 0x0001, 0x3b33: 0x0001, 0x3b34: 0x0001, 0x3b35: 0x0001, 0x3b36: 0x0001, 0x3b37: 0x0001, 0x3b38: 0x0001, 0x3b39: 0x0001, 0x3b3a: 0x0001, 0x3b3b: 0x0001, 0x3b3c: 0x0001, 0x3b3d: 0x0001, 0x3b3e: 0x0001, 0x3b3f: 0x0001, // Block 0xed, offset 0x3b40 0x3b40: 0x0001, 0x3b41: 0x0001, 0x3b42: 0x0001, 0x3b43: 0x0001, 0x3b44: 0x0001, 0x3b45: 0x0001, 0x3b46: 0x0001, 0x3b47: 0x0001, 0x3b48: 0x0001, 0x3b49: 0x0001, 0x3b4a: 0x0001, 0x3b4b: 0x0001, 0x3b4c: 0x0001, 0x3b4d: 0x0001, 0x3b4e: 0x0001, 0x3b4f: 0x0001, 0x3b50: 0x0001, 0x3b51: 0x0001, 0x3b52: 0x0001, 0x3b53: 0x0001, 0x3b54: 0x0001, 0x3b55: 0x0001, 0x3b56: 0x0001, 0x3b57: 0x0001, 0x3b58: 0x0001, 0x3b59: 0x0001, 0x3b5a: 0x0001, 0x3b5b: 0x0001, 0x3b5c: 0x0001, 0x3b5d: 0x0001, 0x3b5e: 0x0001, 0x3b5f: 0x0010, 0x3b60: 0x0010, 0x3b61: 0x0010, 0x3b62: 0x0010, 0x3b63: 0x0010, 0x3b64: 0x0010, 0x3b65: 0x0010, 0x3b66: 0x0010, 0x3b67: 0x0010, 0x3b68: 0x0010, 0x3b69: 0x0010, 0x3b6a: 0x0010, 0x3b70: 0x8000, 0x3b71: 0x8000, 0x3b72: 0x8000, 0x3b73: 0x8000, 0x3b74: 0x8000, 0x3b75: 0x8000, 0x3b76: 0x8000, 0x3b77: 0x8000, 0x3b78: 0x8000, 0x3b79: 0x8000, // Block 0xee, offset 0x3b80 0x3b80: 0x0010, 0x3b81: 0x0010, 0x3b82: 0x0010, 0x3b83: 0x0010, 0x3b85: 0x0001, 0x3b86: 0x0001, 0x3b87: 0x0001, 0x3b88: 0x0001, 0x3b89: 0x0001, 0x3b8a: 0x0001, 0x3b8b: 0x0001, 0x3b8c: 0x0001, 0x3b8f: 0x0001, 0x3b90: 0x0001, 0x3b93: 0x0001, 0x3b94: 0x0001, 0x3b95: 0x0001, 0x3b96: 0x0001, 0x3b97: 0x0001, 0x3b98: 0x0001, 0x3b99: 0x0001, 0x3b9a: 0x0001, 0x3b9b: 0x0001, 0x3b9c: 0x0001, 0x3b9d: 0x0001, 0x3b9e: 0x0001, 0x3b9f: 0x0001, 0x3ba0: 0x0001, 0x3ba1: 0x0001, 0x3ba2: 0x0001, 0x3ba3: 0x0001, 0x3ba4: 0x0001, 0x3ba5: 0x0001, 0x3ba6: 0x0001, 0x3ba7: 0x0001, 0x3ba8: 0x0001, 0x3baa: 0x0001, 0x3bab: 0x0001, 0x3bac: 0x0001, 0x3bad: 0x0001, 0x3bae: 0x0001, 0x3baf: 0x0001, 0x3bb0: 0x0001, 0x3bb2: 0x0001, 0x3bb3: 0x0001, 0x3bb5: 0x0001, 0x3bb6: 0x0001, 0x3bb7: 0x0001, 0x3bb8: 0x0001, 0x3bb9: 0x0001, 0x3bbb: 0x0010, 0x3bbc: 0x0010, 0x3bbd: 0x0001, 0x3bbe: 0x0010, 0x3bbf: 0x0010, // Block 0xef, offset 0x3bc0 0x3bc0: 0x0010, 0x3bc1: 0x0010, 0x3bc2: 0x0010, 0x3bc3: 0x0010, 0x3bc4: 0x0010, 0x3bc7: 0x0010, 0x3bc8: 0x0010, 0x3bcb: 0x0010, 0x3bcc: 0x0010, 0x3bcd: 0x0010, 0x3bd0: 0x0001, 0x3bd7: 0x0010, 0x3bdd: 0x0001, 0x3bde: 0x0001, 0x3bdf: 0x0001, 0x3be0: 0x0001, 0x3be1: 0x0001, 0x3be2: 0x0010, 0x3be3: 0x0010, 0x3be6: 0x0010, 0x3be7: 0x0010, 0x3be8: 0x0010, 0x3be9: 0x0010, 0x3bea: 0x0010, 0x3beb: 0x0010, 0x3bec: 0x0010, 0x3bf0: 0x0010, 0x3bf1: 0x0010, 0x3bf2: 0x0010, 0x3bf3: 0x0010, 0x3bf4: 0x0010, // Block 0xf0, offset 0x3c00 0x3c00: 0x0001, 0x3c01: 0x0001, 0x3c02: 0x0001, 0x3c03: 0x0001, 0x3c04: 0x0001, 0x3c05: 0x0001, 0x3c06: 0x0001, 0x3c07: 0x0001, 0x3c08: 0x0001, 0x3c09: 0x0001, 0x3c0b: 0x0001, 0x3c0e: 0x0001, 0x3c10: 0x0001, 0x3c11: 0x0001, 0x3c12: 0x0001, 0x3c13: 0x0001, 0x3c14: 0x0001, 0x3c15: 0x0001, 0x3c16: 0x0001, 0x3c17: 0x0001, 0x3c18: 0x0001, 0x3c19: 0x0001, 0x3c1a: 0x0001, 0x3c1b: 0x0001, 0x3c1c: 0x0001, 0x3c1d: 0x0001, 0x3c1e: 0x0001, 0x3c1f: 0x0001, 0x3c20: 0x0001, 0x3c21: 0x0001, 0x3c22: 0x0001, 0x3c23: 0x0001, 0x3c24: 0x0001, 0x3c25: 0x0001, 0x3c26: 0x0001, 0x3c27: 0x0001, 0x3c28: 0x0001, 0x3c29: 0x0001, 0x3c2a: 0x0001, 0x3c2b: 0x0001, 0x3c2c: 0x0001, 0x3c2d: 0x0001, 0x3c2e: 0x0001, 0x3c2f: 0x0001, 0x3c30: 0x0001, 0x3c31: 0x0001, 0x3c32: 0x0001, 0x3c33: 0x0001, 0x3c34: 0x0001, 0x3c35: 0x0001, 0x3c37: 0x0001, 0x3c38: 0x0010, 0x3c39: 0x0010, 0x3c3a: 0x0010, 0x3c3b: 0x0010, 0x3c3c: 0x0010, 0x3c3d: 0x0010, 0x3c3e: 0x0010, 0x3c3f: 0x0010, // Block 0xf1, offset 0x3c40 0x3c40: 0x0010, 0x3c42: 0x0010, 0x3c45: 0x0010, 0x3c47: 0x0010, 0x3c48: 0x0010, 0x3c49: 0x0010, 0x3c4a: 0x0010, 0x3c4c: 0x0010, 0x3c4d: 0x0010, 0x3c4e: 0x0010, 0x3c4f: 0x0010, 0x3c50: 0x0010, 0x3c51: 0x0001, 0x3c52: 0x0010, 0x3c53: 0x0001, 0x3c61: 0x0010, 0x3c62: 0x0010, // Block 0xf2, offset 0x3c80 0x3c80: 0x0001, 0x3c81: 0x0001, 0x3c82: 0x0001, 0x3c83: 0x0001, 0x3c84: 0x0001, 0x3c85: 0x0001, 0x3c86: 0x0001, 0x3c87: 0x0001, 0x3c88: 0x0001, 0x3c89: 0x0001, 0x3c8a: 0x0001, 0x3c8b: 0x0001, 0x3c8c: 0x0001, 0x3c8d: 0x0001, 0x3c8e: 0x0001, 0x3c8f: 0x0001, 0x3c90: 0x0001, 0x3c91: 0x0001, 0x3c92: 0x0001, 0x3c93: 0x0001, 0x3c94: 0x0001, 0x3c95: 0x0001, 0x3c96: 0x0001, 0x3c97: 0x0001, 0x3c98: 0x0001, 0x3c99: 0x0001, 0x3c9a: 0x0001, 0x3c9b: 0x0001, 0x3c9c: 0x0001, 0x3c9d: 0x0001, 0x3c9e: 0x0001, 0x3c9f: 0x0001, 0x3ca0: 0x0001, 0x3ca1: 0x0001, 0x3ca2: 0x0001, 0x3ca3: 0x0001, 0x3ca4: 0x0001, 0x3ca5: 0x0001, 0x3ca6: 0x0001, 0x3ca7: 0x0001, 0x3ca8: 0x0001, 0x3ca9: 0x0001, 0x3caa: 0x0001, 0x3cab: 0x0001, 0x3cac: 0x0001, 0x3cad: 0x0001, 0x3cae: 0x0001, 0x3caf: 0x0001, 0x3cb0: 0x0001, 0x3cb1: 0x0001, 0x3cb2: 0x0001, 0x3cb3: 0x0001, 0x3cb4: 0x0001, 0x3cb5: 0x0010, 0x3cb6: 0x0010, 0x3cb7: 0x0010, 0x3cb8: 0x0010, 0x3cb9: 0x0010, 0x3cba: 0x0010, 0x3cbb: 0x0010, 0x3cbc: 0x0010, 0x3cbd: 0x0010, 0x3cbe: 0x0010, 0x3cbf: 0x0010, // Block 0xf3, offset 0x3cc0 0x3cc0: 0x0010, 0x3cc1: 0x0010, 0x3cc2: 0x0010, 0x3cc3: 0x0010, 0x3cc4: 0x0010, 0x3cc5: 0x0010, 0x3cc6: 0x0010, 0x3cc7: 0x0001, 0x3cc8: 0x0001, 0x3cc9: 0x0001, 0x3cca: 0x0001, 0x3cd0: 0x8000, 0x3cd1: 0x8000, 0x3cd2: 0x8000, 0x3cd3: 0x8000, 0x3cd4: 0x8000, 0x3cd5: 0x8000, 0x3cd6: 0x8000, 0x3cd7: 0x8000, 0x3cd8: 0x8000, 0x3cd9: 0x8000, 0x3cde: 0x0010, 0x3cdf: 0x0001, 0x3ce0: 0x0001, 0x3ce1: 0x0001, // Block 0xf4, offset 0x3d00 0x3d00: 0x0001, 0x3d01: 0x0001, 0x3d02: 0x0001, 0x3d03: 0x0001, 0x3d04: 0x0001, 0x3d05: 0x0001, 0x3d06: 0x0001, 0x3d07: 0x0001, 0x3d08: 0x0001, 0x3d09: 0x0001, 0x3d0a: 0x0001, 0x3d0b: 0x0001, 0x3d0c: 0x0001, 0x3d0d: 0x0001, 0x3d0e: 0x0001, 0x3d0f: 0x0001, 0x3d10: 0x0001, 0x3d11: 0x0001, 0x3d12: 0x0001, 0x3d13: 0x0001, 0x3d14: 0x0001, 0x3d15: 0x0001, 0x3d16: 0x0001, 0x3d17: 0x0001, 0x3d18: 0x0001, 0x3d19: 0x0001, 0x3d1a: 0x0001, 0x3d1b: 0x0001, 0x3d1c: 0x0001, 0x3d1d: 0x0001, 0x3d1e: 0x0001, 0x3d1f: 0x0001, 0x3d20: 0x0001, 0x3d21: 0x0001, 0x3d22: 0x0001, 0x3d23: 0x0001, 0x3d24: 0x0001, 0x3d25: 0x0001, 0x3d26: 0x0001, 0x3d27: 0x0001, 0x3d28: 0x0001, 0x3d29: 0x0001, 0x3d2a: 0x0001, 0x3d2b: 0x0001, 0x3d2c: 0x0001, 0x3d2d: 0x0001, 0x3d2e: 0x0001, 0x3d2f: 0x0001, 0x3d30: 0x0010, 0x3d31: 0x0010, 0x3d32: 0x0010, 0x3d33: 0x0010, 0x3d34: 0x0010, 0x3d35: 0x0010, 0x3d36: 0x0010, 0x3d37: 0x0010, 0x3d38: 0x0010, 0x3d39: 0x0010, 0x3d3a: 0x0010, 0x3d3b: 0x0010, 0x3d3c: 0x0010, 0x3d3d: 0x0010, 0x3d3e: 0x0010, 0x3d3f: 0x0010, // Block 0xf5, offset 0x3d40 0x3d40: 0x0010, 0x3d41: 0x0010, 0x3d42: 0x0010, 0x3d43: 0x0010, 0x3d44: 0x0001, 0x3d45: 0x0001, 0x3d47: 0x0001, 0x3d50: 0x8000, 0x3d51: 0x8000, 0x3d52: 0x8000, 0x3d53: 0x8000, 0x3d54: 0x8000, 0x3d55: 0x8000, 0x3d56: 0x8000, 0x3d57: 0x8000, 0x3d58: 0x8000, 0x3d59: 0x8000, // Block 0xf6, offset 0x3d80 0x3d80: 0x0001, 0x3d81: 0x0001, 0x3d82: 0x0001, 0x3d83: 0x0001, 0x3d84: 0x0001, 0x3d85: 0x0001, 0x3d86: 0x0001, 0x3d87: 0x0001, 0x3d88: 0x0001, 0x3d89: 0x0001, 0x3d8a: 0x0001, 0x3d8b: 0x0001, 0x3d8c: 0x0001, 0x3d8d: 0x0001, 0x3d8e: 0x0001, 0x3d8f: 0x0001, 0x3d90: 0x0001, 0x3d91: 0x0001, 0x3d92: 0x0001, 0x3d93: 0x0001, 0x3d94: 0x0001, 0x3d95: 0x0001, 0x3d96: 0x0001, 0x3d97: 0x0001, 0x3d98: 0x0001, 0x3d99: 0x0001, 0x3d9a: 0x0001, 0x3d9b: 0x0001, 0x3d9c: 0x0001, 0x3d9d: 0x0001, 0x3d9e: 0x0001, 0x3d9f: 0x0001, 0x3da0: 0x0001, 0x3da1: 0x0001, 0x3da2: 0x0001, 0x3da3: 0x0001, 0x3da4: 0x0001, 0x3da5: 0x0001, 0x3da6: 0x0001, 0x3da7: 0x0001, 0x3da8: 0x0001, 0x3da9: 0x0001, 0x3daa: 0x0001, 0x3dab: 0x0001, 0x3dac: 0x0001, 0x3dad: 0x0001, 0x3dae: 0x0001, 0x3daf: 0x0010, 0x3db0: 0x0010, 0x3db1: 0x0010, 0x3db2: 0x0010, 0x3db3: 0x0010, 0x3db4: 0x0010, 0x3db5: 0x0010, 0x3db8: 0x0010, 0x3db9: 0x0010, 0x3dba: 0x0010, 0x3dbb: 0x0010, 0x3dbc: 0x0010, 0x3dbd: 0x0010, 0x3dbe: 0x0010, 0x3dbf: 0x0010, // Block 0xf7, offset 0x3dc0 0x3dc0: 0x0010, 0x3dd8: 0x0001, 0x3dd9: 0x0001, 0x3dda: 0x0001, 0x3ddb: 0x0001, 0x3ddc: 0x0010, 0x3ddd: 0x0010, // Block 0xf8, offset 0x3e00 0x3e00: 0x0010, 0x3e04: 0x0001, 0x3e10: 0x8000, 0x3e11: 0x8000, 0x3e12: 0x8000, 0x3e13: 0x8000, 0x3e14: 0x8000, 0x3e15: 0x8000, 0x3e16: 0x8000, 0x3e17: 0x8000, 0x3e18: 0x8000, 0x3e19: 0x8000, // Block 0xf9, offset 0x3e40 0x3e40: 0x0001, 0x3e41: 0x0001, 0x3e42: 0x0001, 0x3e43: 0x0001, 0x3e44: 0x0001, 0x3e45: 0x0001, 0x3e46: 0x0001, 0x3e47: 0x0001, 0x3e48: 0x0001, 0x3e49: 0x0001, 0x3e4a: 0x0001, 0x3e4b: 0x0001, 0x3e4c: 0x0001, 0x3e4d: 0x0001, 0x3e4e: 0x0001, 0x3e4f: 0x0001, 0x3e50: 0x0001, 0x3e51: 0x0001, 0x3e52: 0x0001, 0x3e53: 0x0001, 0x3e54: 0x0001, 0x3e55: 0x0001, 0x3e56: 0x0001, 0x3e57: 0x0001, 0x3e58: 0x0001, 0x3e59: 0x0001, 0x3e5a: 0x0001, 0x3e5b: 0x0001, 0x3e5c: 0x0001, 0x3e5d: 0x0001, 0x3e5e: 0x0001, 0x3e5f: 0x0001, 0x3e60: 0x0001, 0x3e61: 0x0001, 0x3e62: 0x0001, 0x3e63: 0x0001, 0x3e64: 0x0001, 0x3e65: 0x0001, 0x3e66: 0x0001, 0x3e67: 0x0001, 0x3e68: 0x0001, 0x3e69: 0x0001, 0x3e6a: 0x0001, 0x3e6b: 0x0010, 0x3e6c: 0x0010, 0x3e6d: 0x0010, 0x3e6e: 0x0010, 0x3e6f: 0x0010, 0x3e70: 0x0010, 0x3e71: 0x0010, 0x3e72: 0x0010, 0x3e73: 0x0010, 0x3e74: 0x0010, 0x3e75: 0x0010, 0x3e76: 0x0010, 0x3e77: 0x0010, 0x3e78: 0x0001, // Block 0xfa, offset 0x3e80 0x3e80: 0x8000, 0x3e81: 0x8000, 0x3e82: 0x8000, 0x3e83: 0x8000, 0x3e84: 0x8000, 0x3e85: 0x8000, 0x3e86: 0x8000, 0x3e87: 0x8000, 0x3e88: 0x8000, 0x3e89: 0x8000, 0x3e90: 0x8000, 0x3e91: 0x8000, 0x3e92: 0x8000, 0x3e93: 0x8000, 0x3e94: 0x8000, 0x3e95: 0x8000, 0x3e96: 0x8000, 0x3e97: 0x8000, 0x3e98: 0x8000, 0x3e99: 0x8000, 0x3e9a: 0x8000, 0x3e9b: 0x8000, 0x3e9c: 0x8000, 0x3e9d: 0x8000, 0x3e9e: 0x8000, 0x3e9f: 0x8000, 0x3ea0: 0x8000, 0x3ea1: 0x8000, 0x3ea2: 0x8000, 0x3ea3: 0x8000, // Block 0xfb, offset 0x3ec0 0x3edd: 0x0010, 0x3ede: 0x0010, 0x3edf: 0x0010, 0x3ee0: 0x0010, 0x3ee1: 0x0010, 0x3ee2: 0x0010, 0x3ee3: 0x0010, 0x3ee4: 0x0010, 0x3ee5: 0x0010, 0x3ee6: 0x0010, 0x3ee7: 0x0010, 0x3ee8: 0x0010, 0x3ee9: 0x0010, 0x3eea: 0x0010, 0x3eeb: 0x0010, 0x3ef0: 0x8000, 0x3ef1: 0x8000, 0x3ef2: 0x8000, 0x3ef3: 0x8000, 0x3ef4: 0x8000, 0x3ef5: 0x8000, 0x3ef6: 0x8000, 0x3ef7: 0x8000, 0x3ef8: 0x8000, 0x3ef9: 0x8000, // Block 0xfc, offset 0x3f00 0x3f00: 0x0001, 0x3f01: 0x0001, 0x3f02: 0x0001, 0x3f03: 0x0001, 0x3f04: 0x0001, 0x3f05: 0x0001, 0x3f06: 0x0001, 0x3f07: 0x0001, 0x3f08: 0x0001, 0x3f09: 0x0001, 0x3f0a: 0x0001, 0x3f0b: 0x0001, 0x3f0c: 0x0001, 0x3f0d: 0x0001, 0x3f0e: 0x0001, 0x3f0f: 0x0001, 0x3f10: 0x0001, 0x3f11: 0x0001, 0x3f12: 0x0001, 0x3f13: 0x0001, 0x3f14: 0x0001, 0x3f15: 0x0001, 0x3f16: 0x0001, 0x3f17: 0x0001, 0x3f18: 0x0001, 0x3f19: 0x0001, 0x3f1a: 0x0001, 0x3f1b: 0x0001, 0x3f1c: 0x0001, 0x3f1d: 0x0001, 0x3f1e: 0x0001, 0x3f1f: 0x0001, 0x3f20: 0x0001, 0x3f21: 0x0001, 0x3f22: 0x0001, 0x3f23: 0x0001, 0x3f24: 0x0001, 0x3f25: 0x0001, 0x3f26: 0x0001, 0x3f27: 0x0001, 0x3f28: 0x0001, 0x3f29: 0x0001, 0x3f2a: 0x0001, 0x3f2b: 0x0001, 0x3f2c: 0x0010, 0x3f2d: 0x0010, 0x3f2e: 0x0010, 0x3f2f: 0x0010, 0x3f30: 0x0010, 0x3f31: 0x0010, 0x3f32: 0x0010, 0x3f33: 0x0010, 0x3f34: 0x0010, 0x3f35: 0x0010, 0x3f36: 0x0010, 0x3f37: 0x0010, 0x3f38: 0x0010, 0x3f39: 0x0010, 0x3f3a: 0x0010, // Block 0xfd, offset 0x3f40 0x3f60: 0x0001, 0x3f61: 0x0001, 0x3f62: 0x0001, 0x3f63: 0x0001, 0x3f64: 0x0001, 0x3f65: 0x0001, 0x3f66: 0x0001, 0x3f67: 0x0001, 0x3f68: 0x0001, 0x3f69: 0x0001, 0x3f6a: 0x0001, 0x3f6b: 0x0001, 0x3f6c: 0x0001, 0x3f6d: 0x0001, 0x3f6e: 0x0001, 0x3f6f: 0x0001, 0x3f70: 0x0001, 0x3f71: 0x0001, 0x3f72: 0x0001, 0x3f73: 0x0001, 0x3f74: 0x0001, 0x3f75: 0x0001, 0x3f76: 0x0001, 0x3f77: 0x0001, 0x3f78: 0x0001, 0x3f79: 0x0001, 0x3f7a: 0x0001, 0x3f7b: 0x0001, 0x3f7c: 0x0001, 0x3f7d: 0x0001, 0x3f7e: 0x0001, 0x3f7f: 0x0001, // Block 0xfe, offset 0x3f80 0x3f80: 0x0001, 0x3f81: 0x0001, 0x3f82: 0x0001, 0x3f83: 0x0001, 0x3f84: 0x0001, 0x3f85: 0x0001, 0x3f86: 0x0001, 0x3f87: 0x0001, 0x3f88: 0x0001, 0x3f89: 0x0001, 0x3f8a: 0x0001, 0x3f8b: 0x0001, 0x3f8c: 0x0001, 0x3f8d: 0x0001, 0x3f8e: 0x0001, 0x3f8f: 0x0001, 0x3f90: 0x0001, 0x3f91: 0x0001, 0x3f92: 0x0001, 0x3f93: 0x0001, 0x3f94: 0x0001, 0x3f95: 0x0001, 0x3f96: 0x0001, 0x3f97: 0x0001, 0x3f98: 0x0001, 0x3f99: 0x0001, 0x3f9a: 0x0001, 0x3f9b: 0x0001, 0x3f9c: 0x0001, 0x3f9d: 0x0001, 0x3f9e: 0x0001, 0x3f9f: 0x0001, 0x3fa0: 0x8000, 0x3fa1: 0x8000, 0x3fa2: 0x8000, 0x3fa3: 0x8000, 0x3fa4: 0x8000, 0x3fa5: 0x8000, 0x3fa6: 0x8000, 0x3fa7: 0x8000, 0x3fa8: 0x8000, 0x3fa9: 0x8000, 0x3fbf: 0x0001, // Block 0xff, offset 0x3fc0 0x3fc0: 0x0001, 0x3fc1: 0x0001, 0x3fc2: 0x0001, 0x3fc3: 0x0001, 0x3fc4: 0x0001, 0x3fc5: 0x0001, 0x3fc6: 0x0001, 0x3fc9: 0x0001, 0x3fcc: 0x0001, 0x3fcd: 0x0001, 0x3fce: 0x0001, 0x3fcf: 0x0001, 0x3fd0: 0x0001, 0x3fd1: 0x0001, 0x3fd2: 0x0001, 0x3fd3: 0x0001, 0x3fd5: 0x0001, 0x3fd6: 0x0001, 0x3fd8: 0x0001, 0x3fd9: 0x0001, 0x3fda: 0x0001, 0x3fdb: 0x0001, 0x3fdc: 0x0001, 0x3fdd: 0x0001, 0x3fde: 0x0001, 0x3fdf: 0x0001, 0x3fe0: 0x0001, 0x3fe1: 0x0001, 0x3fe2: 0x0001, 0x3fe3: 0x0001, 0x3fe4: 0x0001, 0x3fe5: 0x0001, 0x3fe6: 0x0001, 0x3fe7: 0x0001, 0x3fe8: 0x0001, 0x3fe9: 0x0001, 0x3fea: 0x0001, 0x3feb: 0x0001, 0x3fec: 0x0001, 0x3fed: 0x0001, 0x3fee: 0x0001, 0x3fef: 0x0001, 0x3ff0: 0x0010, 0x3ff1: 0x0010, 0x3ff2: 0x0010, 0x3ff3: 0x0010, 0x3ff4: 0x0010, 0x3ff5: 0x0010, 0x3ff7: 0x0010, 0x3ff8: 0x0010, 0x3ffb: 0x0010, 0x3ffc: 0x0010, 0x3ffd: 0x0010, 0x3ffe: 0x0010, 0x3fff: 0x0001, // Block 0x100, offset 0x4000 0x4000: 0x0010, 0x4001: 0x0001, 0x4002: 0x0010, 0x4003: 0x0010, 0x4010: 0x8000, 0x4011: 0x8000, 0x4012: 0x8000, 0x4013: 0x8000, 0x4014: 0x8000, 0x4015: 0x8000, 0x4016: 0x8000, 0x4017: 0x8000, 0x4018: 0x8000, 0x4019: 0x8000, // Block 0x101, offset 0x4040 0x4060: 0x0001, 0x4061: 0x0001, 0x4062: 0x0001, 0x4063: 0x0001, 0x4064: 0x0001, 0x4065: 0x0001, 0x4066: 0x0001, 0x4067: 0x0001, 0x406a: 0x0001, 0x406b: 0x0001, 0x406c: 0x0001, 0x406d: 0x0001, 0x406e: 0x0001, 0x406f: 0x0001, 0x4070: 0x0001, 0x4071: 0x0001, 0x4072: 0x0001, 0x4073: 0x0001, 0x4074: 0x0001, 0x4075: 0x0001, 0x4076: 0x0001, 0x4077: 0x0001, 0x4078: 0x0001, 0x4079: 0x0001, 0x407a: 0x0001, 0x407b: 0x0001, 0x407c: 0x0001, 0x407d: 0x0001, 0x407e: 0x0001, 0x407f: 0x0001, // Block 0x102, offset 0x4080 0x4080: 0x0001, 0x4081: 0x0001, 0x4082: 0x0001, 0x4083: 0x0001, 0x4084: 0x0001, 0x4085: 0x0001, 0x4086: 0x0001, 0x4087: 0x0001, 0x4088: 0x0001, 0x4089: 0x0001, 0x408a: 0x0001, 0x408b: 0x0001, 0x408c: 0x0001, 0x408d: 0x0001, 0x408e: 0x0001, 0x408f: 0x0001, 0x4090: 0x0001, 0x4091: 0x0010, 0x4092: 0x0010, 0x4093: 0x0010, 0x4094: 0x0010, 0x4095: 0x0010, 0x4096: 0x0010, 0x4097: 0x0010, 0x409a: 0x0010, 0x409b: 0x0010, 0x409c: 0x0010, 0x409d: 0x0010, 0x409e: 0x0010, 0x409f: 0x0010, 0x40a0: 0x0010, 0x40a1: 0x0001, 0x40a3: 0x0001, 0x40a4: 0x0010, // Block 0x103, offset 0x40c0 0x40c0: 0x0001, 0x40c1: 0x0010, 0x40c2: 0x0010, 0x40c3: 0x0010, 0x40c4: 0x0010, 0x40c5: 0x0010, 0x40c6: 0x0010, 0x40c7: 0x0010, 0x40c8: 0x0010, 0x40c9: 0x0010, 0x40ca: 0x0010, 0x40cb: 0x0001, 0x40cc: 0x0001, 0x40cd: 0x0001, 0x40ce: 0x0001, 0x40cf: 0x0001, 0x40d0: 0x0001, 0x40d1: 0x0001, 0x40d2: 0x0001, 0x40d3: 0x0001, 0x40d4: 0x0001, 0x40d5: 0x0001, 0x40d6: 0x0001, 0x40d7: 0x0001, 0x40d8: 0x0001, 0x40d9: 0x0001, 0x40da: 0x0001, 0x40db: 0x0001, 0x40dc: 0x0001, 0x40dd: 0x0001, 0x40de: 0x0001, 0x40df: 0x0001, 0x40e0: 0x0001, 0x40e1: 0x0001, 0x40e2: 0x0001, 0x40e3: 0x0001, 0x40e4: 0x0001, 0x40e5: 0x0001, 0x40e6: 0x0001, 0x40e7: 0x0001, 0x40e8: 0x0001, 0x40e9: 0x0001, 0x40ea: 0x0001, 0x40eb: 0x0001, 0x40ec: 0x0001, 0x40ed: 0x0001, 0x40ee: 0x0001, 0x40ef: 0x0001, 0x40f0: 0x0001, 0x40f1: 0x0001, 0x40f2: 0x0001, 0x40f3: 0x0010, 0x40f4: 0x0010, 0x40f5: 0x0010, 0x40f6: 0x0010, 0x40f7: 0x0010, 0x40f8: 0x0010, 0x40f9: 0x0010, 0x40fa: 0x0001, 0x40fb: 0x0010, 0x40fc: 0x0010, 0x40fd: 0x0010, 0x40fe: 0x0010, // Block 0x104, offset 0x4100 0x4107: 0x0010, 0x4110: 0x0001, 0x4111: 0x0010, 0x4112: 0x0010, 0x4113: 0x0010, 0x4114: 0x0010, 0x4115: 0x0010, 0x4116: 0x0010, 0x4117: 0x0010, 0x4118: 0x0010, 0x4119: 0x0010, 0x411a: 0x0010, 0x411b: 0x0010, 0x411c: 0x0001, 0x411d: 0x0001, 0x411e: 0x0001, 0x411f: 0x0001, 0x4120: 0x0001, 0x4121: 0x0001, 0x4122: 0x0001, 0x4123: 0x0001, 0x4124: 0x0001, 0x4125: 0x0001, 0x4126: 0x0001, 0x4127: 0x0001, 0x4128: 0x0001, 0x4129: 0x0001, 0x412a: 0x0001, 0x412b: 0x0001, 0x412c: 0x0001, 0x412d: 0x0001, 0x412e: 0x0001, 0x412f: 0x0001, 0x4130: 0x0001, 0x4131: 0x0001, 0x4132: 0x0001, 0x4133: 0x0001, 0x4134: 0x0001, 0x4135: 0x0001, 0x4136: 0x0001, 0x4137: 0x0001, 0x4138: 0x0001, 0x4139: 0x0001, 0x413a: 0x0001, 0x413b: 0x0001, 0x413c: 0x0001, 0x413d: 0x0001, 0x413e: 0x0001, 0x413f: 0x0001, // Block 0x105, offset 0x4140 0x4140: 0x0001, 0x4141: 0x0001, 0x4142: 0x0001, 0x4143: 0x0001, 0x4144: 0x0001, 0x4145: 0x0001, 0x4146: 0x0001, 0x4147: 0x0001, 0x4148: 0x0001, 0x4149: 0x0001, 0x414a: 0x0010, 0x414b: 0x0010, 0x414c: 0x0010, 0x414d: 0x0010, 0x414e: 0x0010, 0x414f: 0x0010, 0x4150: 0x0010, 0x4151: 0x0010, 0x4152: 0x0010, 0x4153: 0x0010, 0x4154: 0x0010, 0x4155: 0x0010, 0x4156: 0x0010, 0x4157: 0x0010, 0x4158: 0x0010, 0x4159: 0x0010, 0x415d: 0x0001, 0x4170: 0x0001, 0x4171: 0x0001, 0x4172: 0x0001, 0x4173: 0x0001, 0x4174: 0x0001, 0x4175: 0x0001, 0x4176: 0x0001, 0x4177: 0x0001, 0x4178: 0x0001, 0x4179: 0x0001, 0x417a: 0x0001, 0x417b: 0x0001, 0x417c: 0x0001, 0x417d: 0x0001, 0x417e: 0x0001, 0x417f: 0x0001, // Block 0x106, offset 0x4180 0x41a0: 0x0010, 0x41a1: 0x0010, 0x41a2: 0x0010, 0x41a3: 0x0010, 0x41a4: 0x0010, 0x41a5: 0x0010, 0x41a6: 0x0010, 0x41a7: 0x0010, // Block 0x107, offset 0x41c0 0x41c0: 0x0001, 0x41c1: 0x0001, 0x41c2: 0x0001, 0x41c3: 0x0001, 0x41c4: 0x0001, 0x41c5: 0x0001, 0x41c6: 0x0001, 0x41c7: 0x0001, 0x41c8: 0x0001, 0x41c9: 0x0001, 0x41ca: 0x0001, 0x41cb: 0x0001, 0x41cc: 0x0001, 0x41cd: 0x0001, 0x41ce: 0x0001, 0x41cf: 0x0001, 0x41d0: 0x0001, 0x41d1: 0x0001, 0x41d2: 0x0001, 0x41d3: 0x0001, 0x41d4: 0x0001, 0x41d5: 0x0001, 0x41d6: 0x0001, 0x41d7: 0x0001, 0x41d8: 0x0001, 0x41d9: 0x0001, 0x41da: 0x0001, 0x41db: 0x0001, 0x41dc: 0x0001, 0x41dd: 0x0001, 0x41de: 0x0001, 0x41df: 0x0001, 0x41e0: 0x0001, 0x41f0: 0x8000, 0x41f1: 0x8000, 0x41f2: 0x8000, 0x41f3: 0x8000, 0x41f4: 0x8000, 0x41f5: 0x8000, 0x41f6: 0x8000, 0x41f7: 0x8000, 0x41f8: 0x8000, 0x41f9: 0x8000, // Block 0x108, offset 0x4200 0x4200: 0x0001, 0x4201: 0x0001, 0x4202: 0x0001, 0x4203: 0x0001, 0x4204: 0x0001, 0x4205: 0x0001, 0x4206: 0x0001, 0x4207: 0x0001, 0x4208: 0x0001, 0x420a: 0x0001, 0x420b: 0x0001, 0x420c: 0x0001, 0x420d: 0x0001, 0x420e: 0x0001, 0x420f: 0x0001, 0x4210: 0x0001, 0x4211: 0x0001, 0x4212: 0x0001, 0x4213: 0x0001, 0x4214: 0x0001, 0x4215: 0x0001, 0x4216: 0x0001, 0x4217: 0x0001, 0x4218: 0x0001, 0x4219: 0x0001, 0x421a: 0x0001, 0x421b: 0x0001, 0x421c: 0x0001, 0x421d: 0x0001, 0x421e: 0x0001, 0x421f: 0x0001, 0x4220: 0x0001, 0x4221: 0x0001, 0x4222: 0x0001, 0x4223: 0x0001, 0x4224: 0x0001, 0x4225: 0x0001, 0x4226: 0x0001, 0x4227: 0x0001, 0x4228: 0x0001, 0x4229: 0x0001, 0x422a: 0x0001, 0x422b: 0x0001, 0x422c: 0x0001, 0x422d: 0x0001, 0x422e: 0x0001, 0x422f: 0x0010, 0x4230: 0x0010, 0x4231: 0x0010, 0x4232: 0x0010, 0x4233: 0x0010, 0x4234: 0x0010, 0x4235: 0x0010, 0x4236: 0x0010, 0x4238: 0x0010, 0x4239: 0x0010, 0x423a: 0x0010, 0x423b: 0x0010, 0x423c: 0x0010, 0x423d: 0x0010, 0x423e: 0x0010, 0x423f: 0x0010, // Block 0x109, offset 0x4240 0x4240: 0x0001, 0x4250: 0x8000, 0x4251: 0x8000, 0x4252: 0x8000, 0x4253: 0x8000, 0x4254: 0x8000, 0x4255: 0x8000, 0x4256: 0x8000, 0x4257: 0x8000, 0x4258: 0x8000, 0x4259: 0x8000, 0x4272: 0x0001, 0x4273: 0x0001, 0x4274: 0x0001, 0x4275: 0x0001, 0x4276: 0x0001, 0x4277: 0x0001, 0x4278: 0x0001, 0x4279: 0x0001, 0x427a: 0x0001, 0x427b: 0x0001, 0x427c: 0x0001, 0x427d: 0x0001, 0x427e: 0x0001, 0x427f: 0x0001, // Block 0x10a, offset 0x4280 0x4280: 0x0001, 0x4281: 0x0001, 0x4282: 0x0001, 0x4283: 0x0001, 0x4284: 0x0001, 0x4285: 0x0001, 0x4286: 0x0001, 0x4287: 0x0001, 0x4288: 0x0001, 0x4289: 0x0001, 0x428a: 0x0001, 0x428b: 0x0001, 0x428c: 0x0001, 0x428d: 0x0001, 0x428e: 0x0001, 0x428f: 0x0001, 0x4292: 0x0010, 0x4293: 0x0010, 0x4294: 0x0010, 0x4295: 0x0010, 0x4296: 0x0010, 0x4297: 0x0010, 0x4298: 0x0010, 0x4299: 0x0010, 0x429a: 0x0010, 0x429b: 0x0010, 0x429c: 0x0010, 0x429d: 0x0010, 0x429e: 0x0010, 0x429f: 0x0010, 0x42a0: 0x0010, 0x42a1: 0x0010, 0x42a2: 0x0010, 0x42a3: 0x0010, 0x42a4: 0x0010, 0x42a5: 0x0010, 0x42a6: 0x0010, 0x42a7: 0x0010, 0x42a9: 0x0010, 0x42aa: 0x0010, 0x42ab: 0x0010, 0x42ac: 0x0010, 0x42ad: 0x0010, 0x42ae: 0x0010, 0x42af: 0x0010, 0x42b0: 0x0010, 0x42b1: 0x0010, 0x42b2: 0x0010, 0x42b3: 0x0010, 0x42b4: 0x0010, 0x42b5: 0x0010, 0x42b6: 0x0010, // Block 0x10b, offset 0x42c0 0x42c0: 0x0001, 0x42c1: 0x0001, 0x42c2: 0x0001, 0x42c3: 0x0001, 0x42c4: 0x0001, 0x42c5: 0x0001, 0x42c6: 0x0001, 0x42c8: 0x0001, 0x42c9: 0x0001, 0x42cb: 0x0001, 0x42cc: 0x0001, 0x42cd: 0x0001, 0x42ce: 0x0001, 0x42cf: 0x0001, 0x42d0: 0x0001, 0x42d1: 0x0001, 0x42d2: 0x0001, 0x42d3: 0x0001, 0x42d4: 0x0001, 0x42d5: 0x0001, 0x42d6: 0x0001, 0x42d7: 0x0001, 0x42d8: 0x0001, 0x42d9: 0x0001, 0x42da: 0x0001, 0x42db: 0x0001, 0x42dc: 0x0001, 0x42dd: 0x0001, 0x42de: 0x0001, 0x42df: 0x0001, 0x42e0: 0x0001, 0x42e1: 0x0001, 0x42e2: 0x0001, 0x42e3: 0x0001, 0x42e4: 0x0001, 0x42e5: 0x0001, 0x42e6: 0x0001, 0x42e7: 0x0001, 0x42e8: 0x0001, 0x42e9: 0x0001, 0x42ea: 0x0001, 0x42eb: 0x0001, 0x42ec: 0x0001, 0x42ed: 0x0001, 0x42ee: 0x0001, 0x42ef: 0x0001, 0x42f0: 0x0001, 0x42f1: 0x0010, 0x42f2: 0x0010, 0x42f3: 0x0010, 0x42f4: 0x0010, 0x42f5: 0x0010, 0x42f6: 0x0010, 0x42fa: 0x0010, 0x42fc: 0x0010, 0x42fd: 0x0010, 0x42ff: 0x0010, // Block 0x10c, offset 0x4300 0x4300: 0x0010, 0x4301: 0x0010, 0x4302: 0x0010, 0x4303: 0x0010, 0x4304: 0x0010, 0x4305: 0x0010, 0x4306: 0x0001, 0x4307: 0x0010, 0x4310: 0x8000, 0x4311: 0x8000, 0x4312: 0x8000, 0x4313: 0x8000, 0x4314: 0x8000, 0x4315: 0x8000, 0x4316: 0x8000, 0x4317: 0x8000, 0x4318: 0x8000, 0x4319: 0x8000, 0x4320: 0x0001, 0x4321: 0x0001, 0x4322: 0x0001, 0x4323: 0x0001, 0x4324: 0x0001, 0x4325: 0x0001, 0x4327: 0x0001, 0x4328: 0x0001, 0x432a: 0x0001, 0x432b: 0x0001, 0x432c: 0x0001, 0x432d: 0x0001, 0x432e: 0x0001, 0x432f: 0x0001, 0x4330: 0x0001, 0x4331: 0x0001, 0x4332: 0x0001, 0x4333: 0x0001, 0x4334: 0x0001, 0x4335: 0x0001, 0x4336: 0x0001, 0x4337: 0x0001, 0x4338: 0x0001, 0x4339: 0x0001, 0x433a: 0x0001, 0x433b: 0x0001, 0x433c: 0x0001, 0x433d: 0x0001, 0x433e: 0x0001, 0x433f: 0x0001, // Block 0x10d, offset 0x4340 0x4340: 0x0001, 0x4341: 0x0001, 0x4342: 0x0001, 0x4343: 0x0001, 0x4344: 0x0001, 0x4345: 0x0001, 0x4346: 0x0001, 0x4347: 0x0001, 0x4348: 0x0001, 0x4349: 0x0001, 0x434a: 0x0010, 0x434b: 0x0010, 0x434c: 0x0010, 0x434d: 0x0010, 0x434e: 0x0010, 0x4350: 0x0010, 0x4351: 0x0010, 0x4353: 0x0010, 0x4354: 0x0010, 0x4355: 0x0010, 0x4356: 0x0010, 0x4357: 0x0010, 0x4358: 0x0001, 0x4360: 0x8000, 0x4361: 0x8000, 0x4362: 0x8000, 0x4363: 0x8000, 0x4364: 0x8000, 0x4365: 0x8000, 0x4366: 0x8000, 0x4367: 0x8000, 0x4368: 0x8000, 0x4369: 0x8000, 0x4370: 0x0001, 0x4371: 0x0001, 0x4372: 0x0001, 0x4373: 0x0001, 0x4374: 0x0001, 0x4375: 0x0001, 0x4376: 0x0001, 0x4377: 0x0001, 0x4378: 0x0001, 0x4379: 0x0001, 0x437a: 0x0001, 0x437b: 0x0001, 0x437c: 0x0001, 0x437d: 0x0001, 0x437e: 0x0001, 0x437f: 0x0001, // Block 0x10e, offset 0x4380 0x4380: 0x0001, 0x4381: 0x0001, 0x4382: 0x0001, 0x4383: 0x0001, 0x4384: 0x0001, 0x4385: 0x0001, 0x4386: 0x0001, 0x4387: 0x0001, 0x4388: 0x0001, 0x4389: 0x0001, 0x438a: 0x0001, 0x438b: 0x0001, 0x438c: 0x0001, 0x438d: 0x0001, 0x438e: 0x0001, 0x438f: 0x0001, 0x4390: 0x0001, 0x4391: 0x0001, 0x4392: 0x0001, 0x4393: 0x0001, 0x4394: 0x0001, 0x4395: 0x0001, 0x4396: 0x0001, 0x4397: 0x0001, 0x4398: 0x0001, 0x4399: 0x0001, 0x439a: 0x0001, 0x439b: 0x0001, 0x43a0: 0x8000, 0x43a1: 0x8000, 0x43a2: 0x8000, 0x43a3: 0x8000, 0x43a4: 0x8000, 0x43a5: 0x8000, 0x43a6: 0x8000, 0x43a7: 0x8000, 0x43a8: 0x8000, 0x43a9: 0x8000, // Block 0x10f, offset 0x43c0 0x43e0: 0x0001, 0x43e1: 0x0001, 0x43e2: 0x0001, 0x43e3: 0x0001, 0x43e4: 0x0001, 0x43e5: 0x0001, 0x43e6: 0x0001, 0x43e7: 0x0001, 0x43e8: 0x0001, 0x43e9: 0x0001, 0x43ea: 0x0001, 0x43eb: 0x0001, 0x43ec: 0x0001, 0x43ed: 0x0001, 0x43ee: 0x0001, 0x43ef: 0x0001, 0x43f0: 0x0001, 0x43f1: 0x0001, 0x43f2: 0x0001, 0x43f3: 0x0010, 0x43f4: 0x0010, 0x43f5: 0x0010, 0x43f6: 0x0010, // Block 0x110, offset 0x4400 0x4400: 0x0010, 0x4401: 0x0010, 0x4402: 0x0001, 0x4403: 0x0010, 0x4404: 0x0001, 0x4405: 0x0001, 0x4406: 0x0001, 0x4407: 0x0001, 0x4408: 0x0001, 0x4409: 0x0001, 0x440a: 0x0001, 0x440b: 0x0001, 0x440c: 0x0001, 0x440d: 0x0001, 0x440e: 0x0001, 0x440f: 0x0001, 0x4410: 0x0001, 0x4412: 0x0001, 0x4413: 0x0001, 0x4414: 0x0001, 0x4415: 0x0001, 0x4416: 0x0001, 0x4417: 0x0001, 0x4418: 0x0001, 0x4419: 0x0001, 0x441a: 0x0001, 0x441b: 0x0001, 0x441c: 0x0001, 0x441d: 0x0001, 0x441e: 0x0001, 0x441f: 0x0001, 0x4420: 0x0001, 0x4421: 0x0001, 0x4422: 0x0001, 0x4423: 0x0001, 0x4424: 0x0001, 0x4425: 0x0001, 0x4426: 0x0001, 0x4427: 0x0001, 0x4428: 0x0001, 0x4429: 0x0001, 0x442a: 0x0001, 0x442b: 0x0001, 0x442c: 0x0001, 0x442d: 0x0001, 0x442e: 0x0001, 0x442f: 0x0001, 0x4430: 0x0001, 0x4431: 0x0001, 0x4432: 0x0001, 0x4433: 0x0001, 0x4434: 0x0010, 0x4435: 0x0010, 0x4436: 0x0010, 0x4437: 0x0010, 0x4438: 0x0010, 0x4439: 0x0010, 0x443a: 0x0010, 0x443e: 0x0010, 0x443f: 0x0010, // Block 0x111, offset 0x4440 0x4440: 0x0010, 0x4441: 0x0010, 0x4442: 0x0010, 0x4450: 0x8000, 0x4451: 0x8000, 0x4452: 0x8000, 0x4453: 0x8000, 0x4454: 0x8000, 0x4455: 0x8000, 0x4456: 0x8000, 0x4457: 0x8000, 0x4458: 0x8000, 0x4459: 0x8000, 0x445a: 0x0010, // Block 0x112, offset 0x4480 0x44b0: 0x0001, // Block 0x113, offset 0x44c0 0x44c0: 0x0001, 0x44c1: 0x0001, 0x44c2: 0x0001, 0x44c3: 0x0001, 0x44c4: 0x0001, 0x44c5: 0x0001, 0x44c6: 0x0001, 0x44c7: 0x0001, 0x44c8: 0x0001, 0x44c9: 0x0001, 0x44ca: 0x0001, 0x44cb: 0x0001, 0x44cc: 0x0001, 0x44cd: 0x0001, 0x44ce: 0x0001, 0x44cf: 0x0001, 0x44d0: 0x0001, 0x44d1: 0x0001, 0x44d2: 0x0001, 0x44d3: 0x0001, 0x44d4: 0x0001, 0x44d5: 0x0001, 0x44d6: 0x0001, 0x44d7: 0x0001, 0x44d8: 0x0001, 0x44d9: 0x0001, 0x44da: 0x0001, 0x44db: 0x0001, 0x44dc: 0x0001, 0x44dd: 0x0001, 0x44de: 0x0001, 0x44df: 0x0001, 0x44e0: 0x0001, 0x44e1: 0x0001, 0x44e2: 0x0001, 0x44e3: 0x0001, 0x44e4: 0x0001, 0x44e5: 0x0001, 0x44e6: 0x0001, 0x44e7: 0x0001, 0x44e8: 0x0001, 0x44e9: 0x0001, 0x44ea: 0x0001, 0x44eb: 0x0001, 0x44ec: 0x0001, 0x44ed: 0x0001, 0x44ee: 0x0001, // Block 0x114, offset 0x4500 0x4500: 0x0001, 0x4501: 0x0001, 0x4502: 0x0001, 0x4503: 0x0001, // Block 0x115, offset 0x4540 0x4540: 0x0001, 0x4541: 0x0001, 0x4542: 0x0001, 0x4543: 0x0001, 0x4544: 0x0001, 0x4545: 0x0001, 0x4546: 0x0001, 0x4547: 0x0001, 0x4548: 0x0001, 0x4549: 0x0001, 0x454a: 0x0001, 0x454b: 0x0001, 0x454c: 0x0001, 0x454d: 0x0001, 0x454e: 0x0001, 0x454f: 0x0001, 0x4550: 0x0001, 0x4551: 0x0001, 0x4552: 0x0001, 0x4553: 0x0001, 0x4554: 0x0001, 0x4555: 0x0001, 0x4556: 0x0001, 0x4557: 0x0001, 0x4558: 0x0001, 0x4559: 0x0001, 0x455a: 0x0001, 0x455b: 0x0001, 0x455c: 0x0001, 0x455d: 0x0001, 0x455e: 0x0001, 0x455f: 0x0001, 0x4560: 0x0001, 0x4561: 0x0001, 0x4562: 0x0001, 0x4563: 0x0001, 0x4564: 0x0001, 0x4565: 0x0001, 0x4566: 0x0001, 0x4567: 0x0001, 0x4568: 0x0001, 0x4569: 0x0001, 0x456a: 0x0001, 0x456b: 0x0001, 0x456c: 0x0001, 0x456d: 0x0001, 0x456e: 0x0001, 0x456f: 0x0001, 0x4570: 0x0001, // Block 0x116, offset 0x4580 0x4580: 0x0001, 0x4581: 0x0001, 0x4582: 0x0001, 0x4583: 0x0001, 0x4584: 0x0001, 0x4585: 0x0001, 0x4586: 0x0001, 0x4587: 0x0001, 0x4588: 0x0001, 0x4589: 0x0001, 0x458a: 0x0001, 0x458b: 0x0001, 0x458c: 0x0001, 0x458d: 0x0001, 0x458e: 0x0001, 0x458f: 0x0001, 0x4590: 0x0001, 0x4591: 0x0001, 0x4592: 0x0001, 0x4593: 0x0001, 0x4594: 0x0001, 0x4595: 0x0001, 0x4596: 0x0001, 0x4597: 0x0001, 0x4598: 0x0001, 0x4599: 0x0001, 0x459a: 0x0001, 0x459b: 0x0001, 0x459c: 0x0001, 0x459d: 0x0001, 0x459e: 0x0001, 0x459f: 0x0001, 0x45a0: 0x0001, 0x45a1: 0x0001, 0x45a2: 0x0001, 0x45a3: 0x0001, 0x45a4: 0x0001, 0x45a5: 0x0001, 0x45a6: 0x0001, 0x45a7: 0x0001, 0x45a8: 0x0001, 0x45a9: 0x0001, 0x45aa: 0x0001, 0x45ab: 0x0001, 0x45ac: 0x0001, 0x45ad: 0x0001, 0x45ae: 0x0001, 0x45af: 0x0001, 0x45b0: 0x0080, 0x45b1: 0x0080, 0x45b2: 0x0080, 0x45b3: 0x0080, 0x45b4: 0x0080, 0x45b5: 0x0080, 0x45b6: 0x0080, 0x45b7: 0x0080, 0x45b8: 0x0080, 0x45b9: 0x0080, 0x45ba: 0x0080, 0x45bb: 0x0080, 0x45bc: 0x0080, 0x45bd: 0x0080, 0x45be: 0x0080, 0x45bf: 0x0080, // Block 0x117, offset 0x45c0 0x45c0: 0x0010, 0x45c1: 0x0001, 0x45c2: 0x0001, 0x45c3: 0x0001, 0x45c4: 0x0001, 0x45c5: 0x0001, 0x45c6: 0x0001, 0x45c7: 0x0010, 0x45c8: 0x0010, 0x45c9: 0x0010, 0x45ca: 0x0010, 0x45cb: 0x0010, 0x45cc: 0x0010, 0x45cd: 0x0010, 0x45ce: 0x0010, 0x45cf: 0x0010, 0x45d0: 0x0010, 0x45d1: 0x0010, 0x45d2: 0x0010, 0x45d3: 0x0010, 0x45d4: 0x0010, 0x45d5: 0x0010, 0x45e0: 0x0001, 0x45e1: 0x0001, 0x45e2: 0x0001, 0x45e3: 0x0001, 0x45e4: 0x0001, 0x45e5: 0x0001, 0x45e6: 0x0001, 0x45e7: 0x0001, 0x45e8: 0x0001, 0x45e9: 0x0001, 0x45ea: 0x0001, 0x45eb: 0x0001, 0x45ec: 0x0001, 0x45ed: 0x0001, 0x45ee: 0x0001, 0x45ef: 0x0001, 0x45f0: 0x0001, 0x45f1: 0x0001, 0x45f2: 0x0001, 0x45f3: 0x0001, 0x45f4: 0x0001, 0x45f5: 0x0001, 0x45f6: 0x0001, 0x45f7: 0x0001, 0x45f8: 0x0001, 0x45f9: 0x0001, 0x45fa: 0x0001, 0x45fb: 0x0001, 0x45fc: 0x0001, 0x45fd: 0x0001, 0x45fe: 0x0001, 0x45ff: 0x0001, // Block 0x118, offset 0x4600 0x4600: 0x0001, 0x4601: 0x0001, 0x4602: 0x0001, 0x4603: 0x0001, 0x4604: 0x0001, 0x4605: 0x0001, 0x4606: 0x0001, // Block 0x119, offset 0x4640 0x4640: 0x0001, 0x4641: 0x0001, 0x4642: 0x0001, 0x4643: 0x0001, 0x4644: 0x0001, 0x4645: 0x0001, 0x4646: 0x0001, 0x4647: 0x0001, 0x4648: 0x0001, 0x4649: 0x0001, 0x464a: 0x0001, 0x464b: 0x0001, 0x464c: 0x0001, 0x464d: 0x0001, 0x464e: 0x0001, 0x464f: 0x0001, 0x4650: 0x0001, 0x4651: 0x0001, 0x4652: 0x0001, 0x4653: 0x0001, 0x4654: 0x0001, 0x4655: 0x0001, 0x4656: 0x0001, 0x4657: 0x0001, 0x4658: 0x0001, 0x4659: 0x0001, 0x465a: 0x0001, 0x465b: 0x0001, 0x465c: 0x0001, 0x465d: 0x0001, 0x465e: 0x0010, 0x465f: 0x0010, 0x4660: 0x0010, 0x4661: 0x0010, 0x4662: 0x0010, 0x4663: 0x0010, 0x4664: 0x0010, 0x4665: 0x0010, 0x4666: 0x0010, 0x4667: 0x0010, 0x4668: 0x0010, 0x4669: 0x0010, 0x466a: 0x0010, 0x466b: 0x0010, 0x466c: 0x0010, 0x466d: 0x0010, 0x466e: 0x0010, 0x466f: 0x0010, 0x4670: 0x8000, 0x4671: 0x8000, 0x4672: 0x8000, 0x4673: 0x8000, 0x4674: 0x8000, 0x4675: 0x8000, 0x4676: 0x8000, 0x4677: 0x8000, 0x4678: 0x8000, 0x4679: 0x8000, // Block 0x11a, offset 0x4680 0x4680: 0x0001, 0x4681: 0x0001, 0x4682: 0x0001, 0x4683: 0x0001, 0x4684: 0x0001, 0x4685: 0x0001, 0x4686: 0x0001, 0x4687: 0x0001, 0x4688: 0x0001, 0x4689: 0x0001, 0x468a: 0x0001, 0x468b: 0x0001, 0x468c: 0x0001, 0x468d: 0x0001, 0x468e: 0x0001, 0x468f: 0x0001, 0x4690: 0x0001, 0x4691: 0x0001, 0x4692: 0x0001, 0x4693: 0x0001, 0x4694: 0x0001, 0x4695: 0x0001, 0x4696: 0x0001, 0x4697: 0x0001, 0x4698: 0x0001, 0x4699: 0x0001, 0x469a: 0x0001, 0x469b: 0x0001, 0x469c: 0x0001, 0x469d: 0x0001, 0x469e: 0x0001, 0x46a0: 0x8000, 0x46a1: 0x8000, 0x46a2: 0x8000, 0x46a3: 0x8000, 0x46a4: 0x8000, 0x46a5: 0x8000, 0x46a6: 0x8000, 0x46a7: 0x8000, 0x46a8: 0x8000, 0x46a9: 0x8000, 0x46b0: 0x0001, 0x46b1: 0x0001, 0x46b2: 0x0001, 0x46b3: 0x0001, 0x46b4: 0x0001, 0x46b5: 0x0001, 0x46b6: 0x0001, 0x46b7: 0x0001, 0x46b8: 0x0001, 0x46b9: 0x0001, 0x46ba: 0x0001, 0x46bb: 0x0001, 0x46bc: 0x0001, 0x46bd: 0x0001, 0x46be: 0x0001, 0x46bf: 0x0001, // Block 0x11b, offset 0x46c0 0x46c0: 0x0001, 0x46c1: 0x0001, 0x46c2: 0x0001, 0x46c3: 0x0001, 0x46c4: 0x0001, 0x46c5: 0x0001, 0x46c6: 0x0001, 0x46c7: 0x0001, 0x46c8: 0x0001, 0x46c9: 0x0001, 0x46ca: 0x0001, 0x46cb: 0x0001, 0x46cc: 0x0001, 0x46cd: 0x0001, 0x46ce: 0x0001, 0x46cf: 0x0001, 0x46d0: 0x0001, 0x46d1: 0x0001, 0x46d2: 0x0001, 0x46d3: 0x0001, 0x46d4: 0x0001, 0x46d5: 0x0001, 0x46d6: 0x0001, 0x46d7: 0x0001, 0x46d8: 0x0001, 0x46d9: 0x0001, 0x46da: 0x0001, 0x46db: 0x0001, 0x46dc: 0x0001, 0x46dd: 0x0001, 0x46de: 0x0001, 0x46df: 0x0001, 0x46e0: 0x0001, 0x46e1: 0x0001, 0x46e2: 0x0001, 0x46e3: 0x0001, 0x46e4: 0x0001, 0x46e5: 0x0001, 0x46e6: 0x0001, 0x46e7: 0x0001, 0x46e8: 0x0001, 0x46e9: 0x0001, 0x46ea: 0x0001, 0x46eb: 0x0001, 0x46ec: 0x0001, 0x46ed: 0x0001, 0x46ee: 0x0001, 0x46ef: 0x0001, 0x46f0: 0x0001, 0x46f1: 0x0001, 0x46f2: 0x0001, 0x46f3: 0x0001, 0x46f4: 0x0001, 0x46f5: 0x0001, 0x46f6: 0x0001, 0x46f7: 0x0001, 0x46f8: 0x0001, 0x46f9: 0x0001, 0x46fa: 0x0001, 0x46fb: 0x0001, 0x46fc: 0x0001, 0x46fd: 0x0001, 0x46fe: 0x0001, // Block 0x11c, offset 0x4700 0x4700: 0x8000, 0x4701: 0x8000, 0x4702: 0x8000, 0x4703: 0x8000, 0x4704: 0x8000, 0x4705: 0x8000, 0x4706: 0x8000, 0x4707: 0x8000, 0x4708: 0x8000, 0x4709: 0x8000, 0x4710: 0x0001, 0x4711: 0x0001, 0x4712: 0x0001, 0x4713: 0x0001, 0x4714: 0x0001, 0x4715: 0x0001, 0x4716: 0x0001, 0x4717: 0x0001, 0x4718: 0x0001, 0x4719: 0x0001, 0x471a: 0x0001, 0x471b: 0x0001, 0x471c: 0x0001, 0x471d: 0x0001, 0x471e: 0x0001, 0x471f: 0x0001, 0x4720: 0x0001, 0x4721: 0x0001, 0x4722: 0x0001, 0x4723: 0x0001, 0x4724: 0x0001, 0x4725: 0x0001, 0x4726: 0x0001, 0x4727: 0x0001, 0x4728: 0x0001, 0x4729: 0x0001, 0x472a: 0x0001, 0x472b: 0x0001, 0x472c: 0x0001, 0x472d: 0x0001, 0x4730: 0x0010, 0x4731: 0x0010, 0x4732: 0x0010, 0x4733: 0x0010, 0x4734: 0x0010, // Block 0x11d, offset 0x4740 0x4740: 0x0001, 0x4741: 0x0001, 0x4742: 0x0001, 0x4743: 0x0001, 0x4744: 0x0001, 0x4745: 0x0001, 0x4746: 0x0001, 0x4747: 0x0001, 0x4748: 0x0001, 0x4749: 0x0001, 0x474a: 0x0001, 0x474b: 0x0001, 0x474c: 0x0001, 0x474d: 0x0001, 0x474e: 0x0001, 0x474f: 0x0001, 0x4750: 0x0001, 0x4751: 0x0001, 0x4752: 0x0001, 0x4753: 0x0001, 0x4754: 0x0001, 0x4755: 0x0001, 0x4756: 0x0001, 0x4757: 0x0001, 0x4758: 0x0001, 0x4759: 0x0001, 0x475a: 0x0001, 0x475b: 0x0001, 0x475c: 0x0001, 0x475d: 0x0001, 0x475e: 0x0001, 0x475f: 0x0001, 0x4760: 0x0001, 0x4761: 0x0001, 0x4762: 0x0001, 0x4763: 0x0001, 0x4764: 0x0001, 0x4765: 0x0001, 0x4766: 0x0001, 0x4767: 0x0001, 0x4768: 0x0001, 0x4769: 0x0001, 0x476a: 0x0001, 0x476b: 0x0001, 0x476c: 0x0001, 0x476d: 0x0001, 0x476e: 0x0001, 0x476f: 0x0001, 0x4770: 0x0010, 0x4771: 0x0010, 0x4772: 0x0010, 0x4773: 0x0010, 0x4774: 0x0010, 0x4775: 0x0010, 0x4776: 0x0010, // Block 0x11e, offset 0x4780 0x4780: 0x0001, 0x4781: 0x0001, 0x4782: 0x0001, 0x4783: 0x0001, 0x4790: 0x8000, 0x4791: 0x8000, 0x4792: 0x8000, 0x4793: 0x8000, 0x4794: 0x8000, 0x4795: 0x8000, 0x4796: 0x8000, 0x4797: 0x8000, 0x4798: 0x8000, 0x4799: 0x8000, 0x47a3: 0x0001, 0x47a4: 0x0001, 0x47a5: 0x0001, 0x47a6: 0x0001, 0x47a7: 0x0001, 0x47a8: 0x0001, 0x47a9: 0x0001, 0x47aa: 0x0001, 0x47ab: 0x0001, 0x47ac: 0x0001, 0x47ad: 0x0001, 0x47ae: 0x0001, 0x47af: 0x0001, 0x47b0: 0x0001, 0x47b1: 0x0001, 0x47b2: 0x0001, 0x47b3: 0x0001, 0x47b4: 0x0001, 0x47b5: 0x0001, 0x47b6: 0x0001, 0x47b7: 0x0001, 0x47bd: 0x0001, 0x47be: 0x0001, 0x47bf: 0x0001, // Block 0x11f, offset 0x47c0 0x47c0: 0x0001, 0x47c1: 0x0001, 0x47c2: 0x0001, 0x47c3: 0x0001, 0x47c4: 0x0001, 0x47c5: 0x0001, 0x47c6: 0x0001, 0x47c7: 0x0001, 0x47c8: 0x0001, 0x47c9: 0x0001, 0x47ca: 0x0001, 0x47cb: 0x0001, 0x47cc: 0x0001, 0x47cd: 0x0001, 0x47ce: 0x0001, 0x47cf: 0x0001, // Block 0x120, offset 0x4800 0x4800: 0x0001, 0x4801: 0x0001, 0x4802: 0x0001, 0x4803: 0x0001, 0x4804: 0x0001, 0x4805: 0x0001, 0x4806: 0x0001, 0x4807: 0x0001, 0x4808: 0x0001, 0x4809: 0x0001, 0x480a: 0x0001, 0x480b: 0x0001, 0x480c: 0x0001, 0x480d: 0x0001, 0x480e: 0x0001, 0x480f: 0x0001, 0x4810: 0x0001, 0x4811: 0x0001, 0x4812: 0x0001, 0x4813: 0x0001, 0x4814: 0x0001, 0x4815: 0x0001, 0x4816: 0x0001, 0x4817: 0x0001, 0x4818: 0x0001, 0x4819: 0x0001, 0x481a: 0x0001, 0x481b: 0x0001, 0x481c: 0x0001, 0x481d: 0x0001, 0x481e: 0x0001, 0x481f: 0x0001, 0x4820: 0x0001, 0x4821: 0x0001, 0x4822: 0x0001, 0x4823: 0x0001, 0x4824: 0x0001, 0x4825: 0x0001, 0x4826: 0x0001, 0x4827: 0x0001, 0x4828: 0x0001, 0x4829: 0x0001, 0x482a: 0x0001, 0x482b: 0x0001, 0x482c: 0x0001, 0x4830: 0x8000, 0x4831: 0x8000, 0x4832: 0x8000, 0x4833: 0x8000, 0x4834: 0x8000, 0x4835: 0x8000, 0x4836: 0x8000, 0x4837: 0x8000, 0x4838: 0x8000, 0x4839: 0x8000, // Block 0x121, offset 0x4840 0x4860: 0x0001, 0x4861: 0x0001, 0x4862: 0x0001, 0x4863: 0x0001, 0x4864: 0x0001, 0x4865: 0x0001, 0x4866: 0x0001, 0x4867: 0x0001, 0x4868: 0x0001, 0x4869: 0x0001, 0x486a: 0x0001, 0x486b: 0x0001, 0x486c: 0x0001, 0x486d: 0x0001, 0x486e: 0x0001, 0x486f: 0x0001, 0x4870: 0x0001, 0x4871: 0x0001, 0x4872: 0x0001, 0x4873: 0x0001, 0x4874: 0x0001, 0x4875: 0x0001, 0x4876: 0x0001, 0x4877: 0x0001, 0x4878: 0x0001, 0x487b: 0x0001, 0x487c: 0x0001, 0x487d: 0x0001, 0x487e: 0x0001, 0x487f: 0x0001, // Block 0x122, offset 0x4880 0x4880: 0x0001, 0x4881: 0x0001, 0x4882: 0x0001, 0x4883: 0x0001, 0x4884: 0x0001, 0x4885: 0x0001, 0x4886: 0x0001, 0x4887: 0x0001, 0x4888: 0x0001, 0x4889: 0x0001, 0x488a: 0x0001, 0x488b: 0x0001, 0x488c: 0x0001, 0x488d: 0x0001, 0x488e: 0x0001, 0x488f: 0x0001, 0x4890: 0x0001, 0x4891: 0x0001, 0x4892: 0x0001, 0x4893: 0x0001, // Block 0x123, offset 0x48c0 0x48c0: 0x0001, 0x48c1: 0x0001, 0x48c2: 0x0001, 0x48c3: 0x0001, 0x48c4: 0x0001, 0x48c5: 0x0001, 0x48c6: 0x0001, 0x48c7: 0x0001, 0x48c8: 0x0001, 0x48c9: 0x0001, 0x48ca: 0x0001, 0x48cf: 0x0010, 0x48d0: 0x0001, 0x48d1: 0x0010, 0x48d2: 0x0010, 0x48d3: 0x0010, 0x48d4: 0x0010, 0x48d5: 0x0010, 0x48d6: 0x0010, 0x48d7: 0x0010, 0x48d8: 0x0010, 0x48d9: 0x0010, 0x48da: 0x0010, 0x48db: 0x0010, 0x48dc: 0x0010, 0x48dd: 0x0010, 0x48de: 0x0010, 0x48df: 0x0010, 0x48e0: 0x0010, 0x48e1: 0x0010, 0x48e2: 0x0010, 0x48e3: 0x0010, 0x48e4: 0x0010, 0x48e5: 0x0010, 0x48e6: 0x0010, 0x48e7: 0x0010, 0x48e8: 0x0010, 0x48e9: 0x0010, 0x48ea: 0x0010, 0x48eb: 0x0010, 0x48ec: 0x0010, 0x48ed: 0x0010, 0x48ee: 0x0010, 0x48ef: 0x0010, 0x48f0: 0x0010, 0x48f1: 0x0010, 0x48f2: 0x0010, 0x48f3: 0x0010, 0x48f4: 0x0010, 0x48f5: 0x0010, 0x48f6: 0x0010, 0x48f7: 0x0010, 0x48f8: 0x0010, 0x48f9: 0x0010, 0x48fa: 0x0010, 0x48fb: 0x0010, 0x48fc: 0x0010, 0x48fd: 0x0010, 0x48fe: 0x0010, 0x48ff: 0x0010, // Block 0x124, offset 0x4900 0x4900: 0x0010, 0x4901: 0x0010, 0x4902: 0x0010, 0x4903: 0x0010, 0x4904: 0x0010, 0x4905: 0x0010, 0x4906: 0x0010, 0x4907: 0x0010, 0x490f: 0x0010, 0x4910: 0x0010, 0x4911: 0x0010, 0x4912: 0x0010, 0x4913: 0x0001, 0x4914: 0x0001, 0x4915: 0x0001, 0x4916: 0x0001, 0x4917: 0x0001, 0x4918: 0x0001, 0x4919: 0x0001, 0x491a: 0x0001, 0x491b: 0x0001, 0x491c: 0x0001, 0x491d: 0x0001, 0x491e: 0x0001, 0x491f: 0x0001, // Block 0x125, offset 0x4940 0x4960: 0x0001, 0x4961: 0x0001, 0x4962: 0x0002, 0x4963: 0x0003, 0x4964: 0x0010, 0x4970: 0x0012, 0x4971: 0x0012, // Block 0x126, offset 0x4980 0x49b0: 0x0202, 0x49b1: 0x0202, 0x49b2: 0x0202, 0x49b3: 0x0202, 0x49b5: 0x0202, 0x49b6: 0x0202, 0x49b7: 0x0202, 0x49b8: 0x0202, 0x49b9: 0x0202, 0x49ba: 0x0202, 0x49bb: 0x0202, 0x49bd: 0x0202, 0x49be: 0x0202, // Block 0x127, offset 0x49c0 0x49c0: 0x0202, 0x49c1: 0x0002, 0x49c2: 0x0002, 0x49c3: 0x0002, 0x49c4: 0x0002, 0x49c5: 0x0002, 0x49c6: 0x0002, 0x49c7: 0x0002, 0x49c8: 0x0002, 0x49c9: 0x0002, 0x49ca: 0x0002, 0x49cb: 0x0002, 0x49cc: 0x0002, 0x49cd: 0x0002, 0x49ce: 0x0002, 0x49cf: 0x0002, 0x49d0: 0x0002, 0x49d1: 0x0002, 0x49d2: 0x0002, 0x49d3: 0x0002, 0x49d4: 0x0002, 0x49d5: 0x0002, 0x49d6: 0x0002, 0x49d7: 0x0002, 0x49d8: 0x0002, 0x49d9: 0x0002, 0x49da: 0x0002, 0x49db: 0x0002, 0x49dc: 0x0002, 0x49dd: 0x0002, 0x49de: 0x0002, 0x49df: 0x0002, 0x49e0: 0x0002, 0x49e1: 0x0002, 0x49e2: 0x0002, 0x49e3: 0x0002, 0x49e4: 0x0002, 0x49e5: 0x0002, 0x49e6: 0x0002, 0x49e7: 0x0002, 0x49e8: 0x0002, 0x49e9: 0x0002, 0x49ea: 0x0002, 0x49eb: 0x0002, 0x49ec: 0x0002, 0x49ed: 0x0002, 0x49ee: 0x0002, 0x49ef: 0x0002, 0x49f0: 0x0002, 0x49f1: 0x0002, 0x49f2: 0x0002, 0x49f3: 0x0002, 0x49f4: 0x0002, 0x49f5: 0x0002, 0x49f6: 0x0002, 0x49f7: 0x0002, 0x49f8: 0x0002, 0x49f9: 0x0002, 0x49fa: 0x0002, 0x49fb: 0x0002, 0x49fc: 0x0002, 0x49fd: 0x0002, 0x49fe: 0x0002, 0x49ff: 0x0002, // Block 0x128, offset 0x4a00 0x4a00: 0x0002, 0x4a01: 0x0002, 0x4a02: 0x0002, 0x4a03: 0x0002, 0x4a04: 0x0002, 0x4a05: 0x0002, 0x4a06: 0x0002, 0x4a07: 0x0002, 0x4a08: 0x0002, 0x4a09: 0x0002, 0x4a0a: 0x0002, 0x4a0b: 0x0002, 0x4a0c: 0x0002, 0x4a0d: 0x0002, 0x4a0e: 0x0002, 0x4a0f: 0x0002, 0x4a10: 0x0002, 0x4a11: 0x0002, 0x4a12: 0x0002, 0x4a13: 0x0002, 0x4a14: 0x0002, 0x4a15: 0x0002, 0x4a16: 0x0002, 0x4a17: 0x0002, 0x4a18: 0x0002, 0x4a19: 0x0002, 0x4a1a: 0x0002, 0x4a1b: 0x0002, 0x4a1c: 0x0002, 0x4a1d: 0x0002, 0x4a1e: 0x0002, 0x4a1f: 0x0002, 0x4a20: 0x0202, 0x4a21: 0x0202, 0x4a22: 0x0202, 0x4a32: 0x0002, // Block 0x129, offset 0x4a40 0x4a50: 0x0002, 0x4a51: 0x0002, 0x4a52: 0x0002, 0x4a55: 0x0202, 0x4a64: 0x0202, 0x4a65: 0x0202, 0x4a66: 0x0202, 0x4a67: 0x0202, // Block 0x12a, offset 0x4a80 0x4a80: 0x0001, 0x4a81: 0x0001, 0x4a82: 0x0001, 0x4a83: 0x0001, 0x4a84: 0x0001, 0x4a85: 0x0001, 0x4a86: 0x0001, 0x4a87: 0x0001, 0x4a88: 0x0001, 0x4a89: 0x0001, 0x4a8a: 0x0001, 0x4a8b: 0x0001, 0x4a8c: 0x0001, 0x4a8d: 0x0001, 0x4a8e: 0x0001, 0x4a8f: 0x0001, 0x4a90: 0x0001, 0x4a91: 0x0001, 0x4a92: 0x0001, 0x4a93: 0x0001, 0x4a94: 0x0001, 0x4a95: 0x0001, 0x4a96: 0x0001, 0x4a97: 0x0001, 0x4a98: 0x0001, 0x4a99: 0x0001, 0x4a9a: 0x0001, 0x4a9b: 0x0001, 0x4a9c: 0x0001, 0x4a9d: 0x0001, 0x4a9e: 0x0001, 0x4a9f: 0x0001, 0x4aa0: 0x0001, 0x4aa1: 0x0001, 0x4aa2: 0x0001, 0x4aa3: 0x0001, 0x4aa4: 0x0001, 0x4aa5: 0x0001, 0x4aa6: 0x0001, 0x4aa7: 0x0001, 0x4aa8: 0x0001, 0x4aa9: 0x0001, 0x4aaa: 0x0001, 0x4ab0: 0x0001, 0x4ab1: 0x0001, 0x4ab2: 0x0001, 0x4ab3: 0x0001, 0x4ab4: 0x0001, 0x4ab5: 0x0001, 0x4ab6: 0x0001, 0x4ab7: 0x0001, 0x4ab8: 0x0001, 0x4ab9: 0x0001, 0x4aba: 0x0001, 0x4abb: 0x0001, 0x4abc: 0x0001, // Block 0x12b, offset 0x4ac0 0x4ac0: 0x0001, 0x4ac1: 0x0001, 0x4ac2: 0x0001, 0x4ac3: 0x0001, 0x4ac4: 0x0001, 0x4ac5: 0x0001, 0x4ac6: 0x0001, 0x4ac7: 0x0001, 0x4ac8: 0x0001, 0x4ad0: 0x0001, 0x4ad1: 0x0001, 0x4ad2: 0x0001, 0x4ad3: 0x0001, 0x4ad4: 0x0001, 0x4ad5: 0x0001, 0x4ad6: 0x0001, 0x4ad7: 0x0001, 0x4ad8: 0x0001, 0x4ad9: 0x0001, 0x4add: 0x0010, 0x4ade: 0x0010, 0x4ae0: 0x0080, 0x4ae1: 0x0080, 0x4ae2: 0x0080, 0x4ae3: 0x0080, // Block 0x12c, offset 0x4b00 0x4b30: 0x8000, 0x4b31: 0x8000, 0x4b32: 0x8000, 0x4b33: 0x8000, 0x4b34: 0x8000, 0x4b35: 0x8000, 0x4b36: 0x8000, 0x4b37: 0x8000, 0x4b38: 0x8000, 0x4b39: 0x8000, // Block 0x12d, offset 0x4b40 0x4b40: 0x0010, 0x4b41: 0x0010, 0x4b42: 0x0010, 0x4b43: 0x0010, 0x4b44: 0x0010, 0x4b45: 0x0010, 0x4b46: 0x0010, 0x4b47: 0x0010, 0x4b48: 0x0010, 0x4b49: 0x0010, 0x4b4a: 0x0010, 0x4b4b: 0x0010, 0x4b4c: 0x0010, 0x4b4d: 0x0010, 0x4b4e: 0x0010, 0x4b4f: 0x0010, 0x4b50: 0x0010, 0x4b51: 0x0010, 0x4b52: 0x0010, 0x4b53: 0x0010, 0x4b54: 0x0010, 0x4b55: 0x0010, 0x4b56: 0x0010, 0x4b57: 0x0010, 0x4b58: 0x0010, 0x4b59: 0x0010, 0x4b5a: 0x0010, 0x4b5b: 0x0010, 0x4b5c: 0x0010, 0x4b5d: 0x0010, 0x4b5e: 0x0010, 0x4b5f: 0x0010, 0x4b60: 0x0010, 0x4b61: 0x0010, 0x4b62: 0x0010, 0x4b63: 0x0010, 0x4b64: 0x0010, 0x4b65: 0x0010, 0x4b66: 0x0010, 0x4b67: 0x0010, 0x4b68: 0x0010, 0x4b69: 0x0010, 0x4b6a: 0x0010, 0x4b6b: 0x0010, 0x4b6c: 0x0010, 0x4b6d: 0x0010, 0x4b70: 0x0010, 0x4b71: 0x0010, 0x4b72: 0x0010, 0x4b73: 0x0010, 0x4b74: 0x0010, 0x4b75: 0x0010, 0x4b76: 0x0010, 0x4b77: 0x0010, 0x4b78: 0x0010, 0x4b79: 0x0010, 0x4b7a: 0x0010, 0x4b7b: 0x0010, 0x4b7c: 0x0010, 0x4b7d: 0x0010, 0x4b7e: 0x0010, 0x4b7f: 0x0010, // Block 0x12e, offset 0x4b80 0x4b80: 0x0010, 0x4b81: 0x0010, 0x4b82: 0x0010, 0x4b83: 0x0010, 0x4b84: 0x0010, 0x4b85: 0x0010, 0x4b86: 0x0010, // Block 0x12f, offset 0x4bc0 0x4be5: 0x0010, 0x4be6: 0x0010, 0x4be7: 0x0010, 0x4be8: 0x0010, 0x4be9: 0x0010, 0x4bed: 0x0010, 0x4bee: 0x0010, 0x4bef: 0x0010, 0x4bf0: 0x0010, 0x4bf1: 0x0010, 0x4bf2: 0x0010, 0x4bf3: 0x0080, 0x4bf4: 0x0080, 0x4bf5: 0x0080, 0x4bf6: 0x0080, 0x4bf7: 0x0080, 0x4bf8: 0x0080, 0x4bf9: 0x0080, 0x4bfa: 0x0080, 0x4bfb: 0x0010, 0x4bfc: 0x0010, 0x4bfd: 0x0010, 0x4bfe: 0x0010, 0x4bff: 0x0010, // Block 0x130, offset 0x4c00 0x4c00: 0x0010, 0x4c01: 0x0010, 0x4c02: 0x0010, 0x4c05: 0x0010, 0x4c06: 0x0010, 0x4c07: 0x0010, 0x4c08: 0x0010, 0x4c09: 0x0010, 0x4c0a: 0x0010, 0x4c0b: 0x0010, 0x4c2a: 0x0010, 0x4c2b: 0x0010, 0x4c2c: 0x0010, 0x4c2d: 0x0010, // Block 0x131, offset 0x4c40 0x4c42: 0x0010, 0x4c43: 0x0010, 0x4c44: 0x0010, // Block 0x132, offset 0x4c80 0x4c80: 0x0001, 0x4c81: 0x0001, 0x4c82: 0x0001, 0x4c83: 0x0001, 0x4c84: 0x0001, 0x4c85: 0x0001, 0x4c86: 0x0001, 0x4c87: 0x0001, 0x4c88: 0x0001, 0x4c89: 0x0001, 0x4c8a: 0x0001, 0x4c8b: 0x0001, 0x4c8c: 0x0001, 0x4c8d: 0x0001, 0x4c8e: 0x0001, 0x4c8f: 0x0001, 0x4c90: 0x0001, 0x4c91: 0x0001, 0x4c92: 0x0001, 0x4c93: 0x0001, 0x4c94: 0x0001, 0x4c96: 0x0001, 0x4c97: 0x0001, 0x4c98: 0x0001, 0x4c99: 0x0001, 0x4c9a: 0x0001, 0x4c9b: 0x0001, 0x4c9c: 0x0001, 0x4c9d: 0x0001, 0x4c9e: 0x0001, 0x4c9f: 0x0001, 0x4ca0: 0x0001, 0x4ca1: 0x0001, 0x4ca2: 0x0001, 0x4ca3: 0x0001, 0x4ca4: 0x0001, 0x4ca5: 0x0001, 0x4ca6: 0x0001, 0x4ca7: 0x0001, 0x4ca8: 0x0001, 0x4ca9: 0x0001, 0x4caa: 0x0001, 0x4cab: 0x0001, 0x4cac: 0x0001, 0x4cad: 0x0001, 0x4cae: 0x0001, 0x4caf: 0x0001, 0x4cb0: 0x0001, 0x4cb1: 0x0001, 0x4cb2: 0x0001, 0x4cb3: 0x0001, 0x4cb4: 0x0001, 0x4cb5: 0x0001, 0x4cb6: 0x0001, 0x4cb7: 0x0001, 0x4cb8: 0x0001, 0x4cb9: 0x0001, 0x4cba: 0x0001, 0x4cbb: 0x0001, 0x4cbc: 0x0001, 0x4cbd: 0x0001, 0x4cbe: 0x0001, 0x4cbf: 0x0001, // Block 0x133, offset 0x4cc0 0x4cc0: 0x0001, 0x4cc1: 0x0001, 0x4cc2: 0x0001, 0x4cc3: 0x0001, 0x4cc4: 0x0001, 0x4cc5: 0x0001, 0x4cc6: 0x0001, 0x4cc7: 0x0001, 0x4cc8: 0x0001, 0x4cc9: 0x0001, 0x4cca: 0x0001, 0x4ccb: 0x0001, 0x4ccc: 0x0001, 0x4ccd: 0x0001, 0x4cce: 0x0001, 0x4ccf: 0x0001, 0x4cd0: 0x0001, 0x4cd1: 0x0001, 0x4cd2: 0x0001, 0x4cd3: 0x0001, 0x4cd4: 0x0001, 0x4cd5: 0x0001, 0x4cd6: 0x0001, 0x4cd7: 0x0001, 0x4cd8: 0x0001, 0x4cd9: 0x0001, 0x4cda: 0x0001, 0x4cdb: 0x0001, 0x4cdc: 0x0001, 0x4cde: 0x0001, 0x4cdf: 0x0001, 0x4ce2: 0x0001, 0x4ce5: 0x0001, 0x4ce6: 0x0001, 0x4ce9: 0x0001, 0x4cea: 0x0001, 0x4ceb: 0x0001, 0x4cec: 0x0001, 0x4cee: 0x0001, 0x4cef: 0x0001, 0x4cf0: 0x0001, 0x4cf1: 0x0001, 0x4cf2: 0x0001, 0x4cf3: 0x0001, 0x4cf4: 0x0001, 0x4cf5: 0x0001, 0x4cf6: 0x0001, 0x4cf7: 0x0001, 0x4cf8: 0x0001, 0x4cf9: 0x0001, 0x4cfb: 0x0001, 0x4cfd: 0x0001, 0x4cfe: 0x0001, 0x4cff: 0x0001, // Block 0x134, offset 0x4d00 0x4d00: 0x0001, 0x4d01: 0x0001, 0x4d02: 0x0001, 0x4d03: 0x0001, 0x4d05: 0x0001, 0x4d06: 0x0001, 0x4d07: 0x0001, 0x4d08: 0x0001, 0x4d09: 0x0001, 0x4d0a: 0x0001, 0x4d0b: 0x0001, 0x4d0c: 0x0001, 0x4d0d: 0x0001, 0x4d0e: 0x0001, 0x4d0f: 0x0001, 0x4d10: 0x0001, 0x4d11: 0x0001, 0x4d12: 0x0001, 0x4d13: 0x0001, 0x4d14: 0x0001, 0x4d15: 0x0001, 0x4d16: 0x0001, 0x4d17: 0x0001, 0x4d18: 0x0001, 0x4d19: 0x0001, 0x4d1a: 0x0001, 0x4d1b: 0x0001, 0x4d1c: 0x0001, 0x4d1d: 0x0001, 0x4d1e: 0x0001, 0x4d1f: 0x0001, 0x4d20: 0x0001, 0x4d21: 0x0001, 0x4d22: 0x0001, 0x4d23: 0x0001, 0x4d24: 0x0001, 0x4d25: 0x0001, 0x4d26: 0x0001, 0x4d27: 0x0001, 0x4d28: 0x0001, 0x4d29: 0x0001, 0x4d2a: 0x0001, 0x4d2b: 0x0001, 0x4d2c: 0x0001, 0x4d2d: 0x0001, 0x4d2e: 0x0001, 0x4d2f: 0x0001, 0x4d30: 0x0001, 0x4d31: 0x0001, 0x4d32: 0x0001, 0x4d33: 0x0001, 0x4d34: 0x0001, 0x4d35: 0x0001, 0x4d36: 0x0001, 0x4d37: 0x0001, 0x4d38: 0x0001, 0x4d39: 0x0001, 0x4d3a: 0x0001, 0x4d3b: 0x0001, 0x4d3c: 0x0001, 0x4d3d: 0x0001, 0x4d3e: 0x0001, 0x4d3f: 0x0001, // Block 0x135, offset 0x4d40 0x4d40: 0x0001, 0x4d41: 0x0001, 0x4d42: 0x0001, 0x4d43: 0x0001, 0x4d44: 0x0001, 0x4d45: 0x0001, 0x4d47: 0x0001, 0x4d48: 0x0001, 0x4d49: 0x0001, 0x4d4a: 0x0001, 0x4d4d: 0x0001, 0x4d4e: 0x0001, 0x4d4f: 0x0001, 0x4d50: 0x0001, 0x4d51: 0x0001, 0x4d52: 0x0001, 0x4d53: 0x0001, 0x4d54: 0x0001, 0x4d56: 0x0001, 0x4d57: 0x0001, 0x4d58: 0x0001, 0x4d59: 0x0001, 0x4d5a: 0x0001, 0x4d5b: 0x0001, 0x4d5c: 0x0001, 0x4d5e: 0x0001, 0x4d5f: 0x0001, 0x4d60: 0x0001, 0x4d61: 0x0001, 0x4d62: 0x0001, 0x4d63: 0x0001, 0x4d64: 0x0001, 0x4d65: 0x0001, 0x4d66: 0x0001, 0x4d67: 0x0001, 0x4d68: 0x0001, 0x4d69: 0x0001, 0x4d6a: 0x0001, 0x4d6b: 0x0001, 0x4d6c: 0x0001, 0x4d6d: 0x0001, 0x4d6e: 0x0001, 0x4d6f: 0x0001, 0x4d70: 0x0001, 0x4d71: 0x0001, 0x4d72: 0x0001, 0x4d73: 0x0001, 0x4d74: 0x0001, 0x4d75: 0x0001, 0x4d76: 0x0001, 0x4d77: 0x0001, 0x4d78: 0x0001, 0x4d79: 0x0001, 0x4d7b: 0x0001, 0x4d7c: 0x0001, 0x4d7d: 0x0001, 0x4d7e: 0x0001, // Block 0x136, offset 0x4d80 0x4d80: 0x0001, 0x4d81: 0x0001, 0x4d82: 0x0001, 0x4d83: 0x0001, 0x4d84: 0x0001, 0x4d86: 0x0001, 0x4d8a: 0x0001, 0x4d8b: 0x0001, 0x4d8c: 0x0001, 0x4d8d: 0x0001, 0x4d8e: 0x0001, 0x4d8f: 0x0001, 0x4d90: 0x0001, 0x4d92: 0x0001, 0x4d93: 0x0001, 0x4d94: 0x0001, 0x4d95: 0x0001, 0x4d96: 0x0001, 0x4d97: 0x0001, 0x4d98: 0x0001, 0x4d99: 0x0001, 0x4d9a: 0x0001, 0x4d9b: 0x0001, 0x4d9c: 0x0001, 0x4d9d: 0x0001, 0x4d9e: 0x0001, 0x4d9f: 0x0001, 0x4da0: 0x0001, 0x4da1: 0x0001, 0x4da2: 0x0001, 0x4da3: 0x0001, 0x4da4: 0x0001, 0x4da5: 0x0001, 0x4da6: 0x0001, 0x4da7: 0x0001, 0x4da8: 0x0001, 0x4da9: 0x0001, 0x4daa: 0x0001, 0x4dab: 0x0001, 0x4dac: 0x0001, 0x4dad: 0x0001, 0x4dae: 0x0001, 0x4daf: 0x0001, 0x4db0: 0x0001, 0x4db1: 0x0001, 0x4db2: 0x0001, 0x4db3: 0x0001, 0x4db4: 0x0001, 0x4db5: 0x0001, 0x4db6: 0x0001, 0x4db7: 0x0001, 0x4db8: 0x0001, 0x4db9: 0x0001, 0x4dba: 0x0001, 0x4dbb: 0x0001, 0x4dbc: 0x0001, 0x4dbd: 0x0001, 0x4dbe: 0x0001, 0x4dbf: 0x0001, // Block 0x137, offset 0x4dc0 0x4dc0: 0x0001, 0x4dc1: 0x0001, 0x4dc2: 0x0001, 0x4dc3: 0x0001, 0x4dc4: 0x0001, 0x4dc5: 0x0001, 0x4dc6: 0x0001, 0x4dc7: 0x0001, 0x4dc8: 0x0001, 0x4dc9: 0x0001, 0x4dca: 0x0001, 0x4dcb: 0x0001, 0x4dcc: 0x0001, 0x4dcd: 0x0001, 0x4dce: 0x0001, 0x4dcf: 0x0001, 0x4dd0: 0x0001, 0x4dd1: 0x0001, 0x4dd2: 0x0001, 0x4dd3: 0x0001, 0x4dd4: 0x0001, 0x4dd5: 0x0001, 0x4dd6: 0x0001, 0x4dd7: 0x0001, 0x4dd8: 0x0001, 0x4dd9: 0x0001, 0x4dda: 0x0001, 0x4ddb: 0x0001, 0x4ddc: 0x0001, 0x4ddd: 0x0001, 0x4dde: 0x0001, 0x4ddf: 0x0001, 0x4de0: 0x0001, 0x4de1: 0x0001, 0x4de2: 0x0001, 0x4de3: 0x0001, 0x4de4: 0x0001, 0x4de5: 0x0001, 0x4de8: 0x0001, 0x4de9: 0x0001, 0x4dea: 0x0001, 0x4deb: 0x0001, 0x4dec: 0x0001, 0x4ded: 0x0001, 0x4dee: 0x0001, 0x4def: 0x0001, 0x4df0: 0x0001, 0x4df1: 0x0001, 0x4df2: 0x0001, 0x4df3: 0x0001, 0x4df4: 0x0001, 0x4df5: 0x0001, 0x4df6: 0x0001, 0x4df7: 0x0001, 0x4df8: 0x0001, 0x4df9: 0x0001, 0x4dfa: 0x0001, 0x4dfb: 0x0001, 0x4dfc: 0x0001, 0x4dfd: 0x0001, 0x4dfe: 0x0001, 0x4dff: 0x0001, // Block 0x138, offset 0x4e00 0x4e00: 0x0001, 0x4e02: 0x0001, 0x4e03: 0x0001, 0x4e04: 0x0001, 0x4e05: 0x0001, 0x4e06: 0x0001, 0x4e07: 0x0001, 0x4e08: 0x0001, 0x4e09: 0x0001, 0x4e0a: 0x0001, 0x4e0b: 0x0001, 0x4e0c: 0x0001, 0x4e0d: 0x0001, 0x4e0e: 0x0001, 0x4e0f: 0x0001, 0x4e10: 0x0001, 0x4e11: 0x0001, 0x4e12: 0x0001, 0x4e13: 0x0001, 0x4e14: 0x0001, 0x4e15: 0x0001, 0x4e16: 0x0001, 0x4e17: 0x0001, 0x4e18: 0x0001, 0x4e19: 0x0001, 0x4e1a: 0x0001, 0x4e1c: 0x0001, 0x4e1d: 0x0001, 0x4e1e: 0x0001, 0x4e1f: 0x0001, 0x4e20: 0x0001, 0x4e21: 0x0001, 0x4e22: 0x0001, 0x4e23: 0x0001, 0x4e24: 0x0001, 0x4e25: 0x0001, 0x4e26: 0x0001, 0x4e27: 0x0001, 0x4e28: 0x0001, 0x4e29: 0x0001, 0x4e2a: 0x0001, 0x4e2b: 0x0001, 0x4e2c: 0x0001, 0x4e2d: 0x0001, 0x4e2e: 0x0001, 0x4e2f: 0x0001, 0x4e30: 0x0001, 0x4e31: 0x0001, 0x4e32: 0x0001, 0x4e33: 0x0001, 0x4e34: 0x0001, 0x4e35: 0x0001, 0x4e36: 0x0001, 0x4e37: 0x0001, 0x4e38: 0x0001, 0x4e39: 0x0001, 0x4e3a: 0x0001, 0x4e3c: 0x0001, 0x4e3d: 0x0001, 0x4e3e: 0x0001, 0x4e3f: 0x0001, // Block 0x139, offset 0x4e40 0x4e40: 0x0001, 0x4e41: 0x0001, 0x4e42: 0x0001, 0x4e43: 0x0001, 0x4e44: 0x0001, 0x4e45: 0x0001, 0x4e46: 0x0001, 0x4e47: 0x0001, 0x4e48: 0x0001, 0x4e49: 0x0001, 0x4e4a: 0x0001, 0x4e4b: 0x0001, 0x4e4c: 0x0001, 0x4e4d: 0x0001, 0x4e4e: 0x0001, 0x4e4f: 0x0001, 0x4e50: 0x0001, 0x4e51: 0x0001, 0x4e52: 0x0001, 0x4e53: 0x0001, 0x4e54: 0x0001, 0x4e56: 0x0001, 0x4e57: 0x0001, 0x4e58: 0x0001, 0x4e59: 0x0001, 0x4e5a: 0x0001, 0x4e5b: 0x0001, 0x4e5c: 0x0001, 0x4e5d: 0x0001, 0x4e5e: 0x0001, 0x4e5f: 0x0001, 0x4e60: 0x0001, 0x4e61: 0x0001, 0x4e62: 0x0001, 0x4e63: 0x0001, 0x4e64: 0x0001, 0x4e65: 0x0001, 0x4e66: 0x0001, 0x4e67: 0x0001, 0x4e68: 0x0001, 0x4e69: 0x0001, 0x4e6a: 0x0001, 0x4e6b: 0x0001, 0x4e6c: 0x0001, 0x4e6d: 0x0001, 0x4e6e: 0x0001, 0x4e6f: 0x0001, 0x4e70: 0x0001, 0x4e71: 0x0001, 0x4e72: 0x0001, 0x4e73: 0x0001, 0x4e74: 0x0001, 0x4e76: 0x0001, 0x4e77: 0x0001, 0x4e78: 0x0001, 0x4e79: 0x0001, 0x4e7a: 0x0001, 0x4e7b: 0x0001, 0x4e7c: 0x0001, 0x4e7d: 0x0001, 0x4e7e: 0x0001, 0x4e7f: 0x0001, // Block 0x13a, offset 0x4e80 0x4e80: 0x0001, 0x4e81: 0x0001, 0x4e82: 0x0001, 0x4e83: 0x0001, 0x4e84: 0x0001, 0x4e85: 0x0001, 0x4e86: 0x0001, 0x4e87: 0x0001, 0x4e88: 0x0001, 0x4e89: 0x0001, 0x4e8a: 0x0001, 0x4e8b: 0x0001, 0x4e8c: 0x0001, 0x4e8d: 0x0001, 0x4e8e: 0x0001, 0x4e90: 0x0001, 0x4e91: 0x0001, 0x4e92: 0x0001, 0x4e93: 0x0001, 0x4e94: 0x0001, 0x4e95: 0x0001, 0x4e96: 0x0001, 0x4e97: 0x0001, 0x4e98: 0x0001, 0x4e99: 0x0001, 0x4e9a: 0x0001, 0x4e9b: 0x0001, 0x4e9c: 0x0001, 0x4e9d: 0x0001, 0x4e9e: 0x0001, 0x4e9f: 0x0001, 0x4ea0: 0x0001, 0x4ea1: 0x0001, 0x4ea2: 0x0001, 0x4ea3: 0x0001, 0x4ea4: 0x0001, 0x4ea5: 0x0001, 0x4ea6: 0x0001, 0x4ea7: 0x0001, 0x4ea8: 0x0001, 0x4ea9: 0x0001, 0x4eaa: 0x0001, 0x4eab: 0x0001, 0x4eac: 0x0001, 0x4ead: 0x0001, 0x4eae: 0x0001, 0x4eb0: 0x0001, 0x4eb1: 0x0001, 0x4eb2: 0x0001, 0x4eb3: 0x0001, 0x4eb4: 0x0001, 0x4eb5: 0x0001, 0x4eb6: 0x0001, 0x4eb7: 0x0001, 0x4eb8: 0x0001, 0x4eb9: 0x0001, 0x4eba: 0x0001, 0x4ebb: 0x0001, 0x4ebc: 0x0001, 0x4ebd: 0x0001, 0x4ebe: 0x0001, 0x4ebf: 0x0001, // Block 0x13b, offset 0x4ec0 0x4ec0: 0x0001, 0x4ec1: 0x0001, 0x4ec2: 0x0001, 0x4ec3: 0x0001, 0x4ec4: 0x0001, 0x4ec5: 0x0001, 0x4ec6: 0x0001, 0x4ec7: 0x0001, 0x4ec8: 0x0001, 0x4eca: 0x0001, 0x4ecb: 0x0001, 0x4ecc: 0x0001, 0x4ecd: 0x0001, 0x4ece: 0x0001, 0x4ecf: 0x0001, 0x4ed0: 0x0001, 0x4ed1: 0x0001, 0x4ed2: 0x0001, 0x4ed3: 0x0001, 0x4ed4: 0x0001, 0x4ed5: 0x0001, 0x4ed6: 0x0001, 0x4ed7: 0x0001, 0x4ed8: 0x0001, 0x4ed9: 0x0001, 0x4eda: 0x0001, 0x4edb: 0x0001, 0x4edc: 0x0001, 0x4edd: 0x0001, 0x4ede: 0x0001, 0x4edf: 0x0001, 0x4ee0: 0x0001, 0x4ee1: 0x0001, 0x4ee2: 0x0001, 0x4ee3: 0x0001, 0x4ee4: 0x0001, 0x4ee5: 0x0001, 0x4ee6: 0x0001, 0x4ee7: 0x0001, 0x4ee8: 0x0001, 0x4eea: 0x0001, 0x4eeb: 0x0001, 0x4eec: 0x0001, 0x4eed: 0x0001, 0x4eee: 0x0001, 0x4eef: 0x0001, 0x4ef0: 0x0001, 0x4ef1: 0x0001, 0x4ef2: 0x0001, 0x4ef3: 0x0001, 0x4ef4: 0x0001, 0x4ef5: 0x0001, 0x4ef6: 0x0001, 0x4ef7: 0x0001, 0x4ef8: 0x0001, 0x4ef9: 0x0001, 0x4efa: 0x0001, 0x4efb: 0x0001, 0x4efc: 0x0001, 0x4efd: 0x0001, 0x4efe: 0x0001, 0x4eff: 0x0001, // Block 0x13c, offset 0x4f00 0x4f00: 0x0001, 0x4f01: 0x0001, 0x4f02: 0x0001, 0x4f04: 0x0001, 0x4f05: 0x0001, 0x4f06: 0x0001, 0x4f07: 0x0001, 0x4f08: 0x0001, 0x4f09: 0x0001, 0x4f0a: 0x0001, 0x4f0b: 0x0001, 0x4f0e: 0x8000, 0x4f0f: 0x8000, 0x4f10: 0x8000, 0x4f11: 0x8000, 0x4f12: 0x8000, 0x4f13: 0x8000, 0x4f14: 0x8000, 0x4f15: 0x8000, 0x4f16: 0x8000, 0x4f17: 0x8000, 0x4f18: 0x8000, 0x4f19: 0x8000, 0x4f1a: 0x8000, 0x4f1b: 0x8000, 0x4f1c: 0x8000, 0x4f1d: 0x8000, 0x4f1e: 0x8000, 0x4f1f: 0x8000, 0x4f20: 0x8000, 0x4f21: 0x8000, 0x4f22: 0x8000, 0x4f23: 0x8000, 0x4f24: 0x8000, 0x4f25: 0x8000, 0x4f26: 0x8000, 0x4f27: 0x8000, 0x4f28: 0x8000, 0x4f29: 0x8000, 0x4f2a: 0x8000, 0x4f2b: 0x8000, 0x4f2c: 0x8000, 0x4f2d: 0x8000, 0x4f2e: 0x8000, 0x4f2f: 0x8000, 0x4f30: 0x8000, 0x4f31: 0x8000, 0x4f32: 0x8000, 0x4f33: 0x8000, 0x4f34: 0x8000, 0x4f35: 0x8000, 0x4f36: 0x8000, 0x4f37: 0x8000, 0x4f38: 0x8000, 0x4f39: 0x8000, 0x4f3a: 0x8000, 0x4f3b: 0x8000, 0x4f3c: 0x8000, 0x4f3d: 0x8000, 0x4f3e: 0x8000, 0x4f3f: 0x8000, // Block 0x13d, offset 0x4f40 0x4f40: 0x0010, 0x4f41: 0x0010, 0x4f42: 0x0010, 0x4f43: 0x0010, 0x4f44: 0x0010, 0x4f45: 0x0010, 0x4f46: 0x0010, 0x4f47: 0x0010, 0x4f48: 0x0010, 0x4f49: 0x0010, 0x4f4a: 0x0010, 0x4f4b: 0x0010, 0x4f4c: 0x0010, 0x4f4d: 0x0010, 0x4f4e: 0x0010, 0x4f4f: 0x0010, 0x4f50: 0x0010, 0x4f51: 0x0010, 0x4f52: 0x0010, 0x4f53: 0x0010, 0x4f54: 0x0010, 0x4f55: 0x0010, 0x4f56: 0x0010, 0x4f57: 0x0010, 0x4f58: 0x0010, 0x4f59: 0x0010, 0x4f5a: 0x0010, 0x4f5b: 0x0010, 0x4f5c: 0x0010, 0x4f5d: 0x0010, 0x4f5e: 0x0010, 0x4f5f: 0x0010, 0x4f60: 0x0010, 0x4f61: 0x0010, 0x4f62: 0x0010, 0x4f63: 0x0010, 0x4f64: 0x0010, 0x4f65: 0x0010, 0x4f66: 0x0010, 0x4f67: 0x0010, 0x4f68: 0x0010, 0x4f69: 0x0010, 0x4f6a: 0x0010, 0x4f6b: 0x0010, 0x4f6c: 0x0010, 0x4f6d: 0x0010, 0x4f6e: 0x0010, 0x4f6f: 0x0010, 0x4f70: 0x0010, 0x4f71: 0x0010, 0x4f72: 0x0010, 0x4f73: 0x0010, 0x4f74: 0x0010, 0x4f75: 0x0010, 0x4f76: 0x0010, 0x4f7b: 0x0010, 0x4f7c: 0x0010, 0x4f7d: 0x0010, 0x4f7e: 0x0010, 0x4f7f: 0x0010, // Block 0x13e, offset 0x4f80 0x4f80: 0x0010, 0x4f81: 0x0010, 0x4f82: 0x0010, 0x4f83: 0x0010, 0x4f84: 0x0010, 0x4f85: 0x0010, 0x4f86: 0x0010, 0x4f87: 0x0010, 0x4f88: 0x0010, 0x4f89: 0x0010, 0x4f8a: 0x0010, 0x4f8b: 0x0010, 0x4f8c: 0x0010, 0x4f8d: 0x0010, 0x4f8e: 0x0010, 0x4f8f: 0x0010, 0x4f90: 0x0010, 0x4f91: 0x0010, 0x4f92: 0x0010, 0x4f93: 0x0010, 0x4f94: 0x0010, 0x4f95: 0x0010, 0x4f96: 0x0010, 0x4f97: 0x0010, 0x4f98: 0x0010, 0x4f99: 0x0010, 0x4f9a: 0x0010, 0x4f9b: 0x0010, 0x4f9c: 0x0010, 0x4f9d: 0x0010, 0x4f9e: 0x0010, 0x4f9f: 0x0010, 0x4fa0: 0x0010, 0x4fa1: 0x0010, 0x4fa2: 0x0010, 0x4fa3: 0x0010, 0x4fa4: 0x0010, 0x4fa5: 0x0010, 0x4fa6: 0x0010, 0x4fa7: 0x0010, 0x4fa8: 0x0010, 0x4fa9: 0x0010, 0x4faa: 0x0010, 0x4fab: 0x0010, 0x4fac: 0x0010, 0x4fb5: 0x0010, // Block 0x13f, offset 0x4fc0 0x4fc4: 0x0010, 0x4fdb: 0x0010, 0x4fdc: 0x0010, 0x4fdd: 0x0010, 0x4fde: 0x0010, 0x4fdf: 0x0010, 0x4fe1: 0x0010, 0x4fe2: 0x0010, 0x4fe3: 0x0010, 0x4fe4: 0x0010, 0x4fe5: 0x0010, 0x4fe6: 0x0010, 0x4fe7: 0x0010, 0x4fe8: 0x0010, 0x4fe9: 0x0010, 0x4fea: 0x0010, 0x4feb: 0x0010, 0x4fec: 0x0010, 0x4fed: 0x0010, 0x4fee: 0x0010, 0x4fef: 0x0010, // Block 0x140, offset 0x5000 0x5000: 0x0001, 0x5001: 0x0001, 0x5002: 0x0001, 0x5003: 0x0001, 0x5004: 0x0001, 0x5005: 0x0001, 0x5006: 0x0001, 0x5007: 0x0001, 0x5008: 0x0001, 0x5009: 0x0001, 0x500a: 0x0001, 0x500b: 0x0001, 0x500c: 0x0001, 0x500d: 0x0001, 0x500e: 0x0001, 0x500f: 0x0001, 0x5010: 0x0001, 0x5011: 0x0001, 0x5012: 0x0001, 0x5013: 0x0001, 0x5014: 0x0001, 0x5015: 0x0001, 0x5016: 0x0001, 0x5017: 0x0001, 0x5018: 0x0001, 0x5019: 0x0001, 0x501a: 0x0001, 0x501b: 0x0001, 0x501c: 0x0001, 0x501d: 0x0001, 0x501e: 0x0001, 0x5025: 0x0001, 0x5026: 0x0001, 0x5027: 0x0001, 0x5028: 0x0001, 0x5029: 0x0001, 0x502a: 0x0001, // Block 0x141, offset 0x5040 0x5040: 0x0010, 0x5041: 0x0010, 0x5042: 0x0010, 0x5043: 0x0010, 0x5044: 0x0010, 0x5045: 0x0010, 0x5046: 0x0010, 0x5048: 0x0010, 0x5049: 0x0010, 0x504a: 0x0010, 0x504b: 0x0010, 0x504c: 0x0010, 0x504d: 0x0010, 0x504e: 0x0010, 0x504f: 0x0010, 0x5050: 0x0010, 0x5051: 0x0010, 0x5052: 0x0010, 0x5053: 0x0010, 0x5054: 0x0010, 0x5055: 0x0010, 0x5056: 0x0010, 0x5057: 0x0010, 0x5058: 0x0010, 0x505b: 0x0010, 0x505c: 0x0010, 0x505d: 0x0010, 0x505e: 0x0010, 0x505f: 0x0010, 0x5060: 0x0010, 0x5061: 0x0010, 0x5063: 0x0010, 0x5064: 0x0010, 0x5066: 0x0010, 0x5067: 0x0010, 0x5068: 0x0010, 0x5069: 0x0010, 0x506a: 0x0010, 0x5070: 0x0001, 0x5071: 0x0001, 0x5072: 0x0001, 0x5073: 0x0001, 0x5074: 0x0001, 0x5075: 0x0001, 0x5076: 0x0001, 0x5077: 0x0001, 0x5078: 0x0001, 0x5079: 0x0001, 0x507a: 0x0001, 0x507b: 0x0001, 0x507c: 0x0001, 0x507d: 0x0001, 0x507e: 0x0001, 0x507f: 0x0001, // Block 0x142, offset 0x5080 0x5080: 0x0001, 0x5081: 0x0001, 0x5082: 0x0001, 0x5083: 0x0001, 0x5084: 0x0001, 0x5085: 0x0001, 0x5086: 0x0001, 0x5087: 0x0001, 0x5088: 0x0001, 0x5089: 0x0001, 0x508a: 0x0001, 0x508b: 0x0001, 0x508c: 0x0001, 0x508d: 0x0001, 0x508e: 0x0001, 0x508f: 0x0001, 0x5090: 0x0001, 0x5091: 0x0001, 0x5092: 0x0001, 0x5093: 0x0001, 0x5094: 0x0001, 0x5095: 0x0001, 0x5096: 0x0001, 0x5097: 0x0001, 0x5098: 0x0001, 0x5099: 0x0001, 0x509a: 0x0001, 0x509b: 0x0001, 0x509c: 0x0001, 0x509d: 0x0001, 0x509e: 0x0001, 0x509f: 0x0001, 0x50a0: 0x0001, 0x50a1: 0x0001, 0x50a2: 0x0001, 0x50a3: 0x0001, 0x50a4: 0x0001, 0x50a5: 0x0001, 0x50a6: 0x0001, 0x50a7: 0x0001, 0x50a8: 0x0001, 0x50a9: 0x0001, 0x50aa: 0x0001, 0x50ab: 0x0001, 0x50ac: 0x0001, 0x50ad: 0x0001, // Block 0x143, offset 0x50c0 0x50cf: 0x0010, // Block 0x144, offset 0x5100 0x5100: 0x0001, 0x5101: 0x0001, 0x5102: 0x0001, 0x5103: 0x0001, 0x5104: 0x0001, 0x5105: 0x0001, 0x5106: 0x0001, 0x5107: 0x0001, 0x5108: 0x0001, 0x5109: 0x0001, 0x510a: 0x0001, 0x510b: 0x0001, 0x510c: 0x0001, 0x510d: 0x0001, 0x510e: 0x0001, 0x510f: 0x0001, 0x5110: 0x0001, 0x5111: 0x0001, 0x5112: 0x0001, 0x5113: 0x0001, 0x5114: 0x0001, 0x5115: 0x0001, 0x5116: 0x0001, 0x5117: 0x0001, 0x5118: 0x0001, 0x5119: 0x0001, 0x511a: 0x0001, 0x511b: 0x0001, 0x511c: 0x0001, 0x511d: 0x0001, 0x511e: 0x0001, 0x511f: 0x0001, 0x5120: 0x0001, 0x5121: 0x0001, 0x5122: 0x0001, 0x5123: 0x0001, 0x5124: 0x0001, 0x5125: 0x0001, 0x5126: 0x0001, 0x5127: 0x0001, 0x5128: 0x0001, 0x5129: 0x0001, 0x512a: 0x0001, 0x512b: 0x0001, 0x512c: 0x0001, 0x5130: 0x0010, 0x5131: 0x0010, 0x5132: 0x0010, 0x5133: 0x0010, 0x5134: 0x0010, 0x5135: 0x0010, 0x5136: 0x0010, 0x5137: 0x0001, 0x5138: 0x0001, 0x5139: 0x0001, 0x513a: 0x0001, 0x513b: 0x0001, 0x513c: 0x0001, 0x513d: 0x0001, // Block 0x145, offset 0x5140 0x5140: 0x8000, 0x5141: 0x8000, 0x5142: 0x8000, 0x5143: 0x8000, 0x5144: 0x8000, 0x5145: 0x8000, 0x5146: 0x8000, 0x5147: 0x8000, 0x5148: 0x8000, 0x5149: 0x8000, 0x514e: 0x0001, // Block 0x146, offset 0x5180 0x5190: 0x0001, 0x5191: 0x0001, 0x5192: 0x0001, 0x5193: 0x0001, 0x5194: 0x0001, 0x5195: 0x0001, 0x5196: 0x0001, 0x5197: 0x0001, 0x5198: 0x0001, 0x5199: 0x0001, 0x519a: 0x0001, 0x519b: 0x0001, 0x519c: 0x0001, 0x519d: 0x0001, 0x519e: 0x0001, 0x519f: 0x0001, 0x51a0: 0x0001, 0x51a1: 0x0001, 0x51a2: 0x0001, 0x51a3: 0x0001, 0x51a4: 0x0001, 0x51a5: 0x0001, 0x51a6: 0x0001, 0x51a7: 0x0001, 0x51a8: 0x0001, 0x51a9: 0x0001, 0x51aa: 0x0001, 0x51ab: 0x0001, 0x51ac: 0x0001, 0x51ad: 0x0001, 0x51ae: 0x0010, // Block 0x147, offset 0x51c0 0x51c0: 0x0001, 0x51c1: 0x0001, 0x51c2: 0x0001, 0x51c3: 0x0001, 0x51c4: 0x0001, 0x51c5: 0x0001, 0x51c6: 0x0001, 0x51c7: 0x0001, 0x51c8: 0x0001, 0x51c9: 0x0001, 0x51ca: 0x0001, 0x51cb: 0x0001, 0x51cc: 0x0001, 0x51cd: 0x0001, 0x51ce: 0x0001, 0x51cf: 0x0001, 0x51d0: 0x0001, 0x51d1: 0x0001, 0x51d2: 0x0001, 0x51d3: 0x0001, 0x51d4: 0x0001, 0x51d5: 0x0001, 0x51d6: 0x0001, 0x51d7: 0x0001, 0x51d8: 0x0001, 0x51d9: 0x0001, 0x51da: 0x0001, 0x51db: 0x0001, 0x51dc: 0x0001, 0x51dd: 0x0001, 0x51de: 0x0001, 0x51df: 0x0001, 0x51e0: 0x0001, 0x51e1: 0x0001, 0x51e2: 0x0001, 0x51e3: 0x0001, 0x51e4: 0x0001, 0x51e5: 0x0001, 0x51e6: 0x0001, 0x51e7: 0x0001, 0x51e8: 0x0001, 0x51e9: 0x0001, 0x51ea: 0x0001, 0x51eb: 0x0001, 0x51ec: 0x0010, 0x51ed: 0x0010, 0x51ee: 0x0010, 0x51ef: 0x0010, 0x51f0: 0x8000, 0x51f1: 0x8000, 0x51f2: 0x8000, 0x51f3: 0x8000, 0x51f4: 0x8000, 0x51f5: 0x8000, 0x51f6: 0x8000, 0x51f7: 0x8000, 0x51f8: 0x8000, 0x51f9: 0x8000, // Block 0x148, offset 0x5200 0x5210: 0x0001, 0x5211: 0x0001, 0x5212: 0x0001, 0x5213: 0x0001, 0x5214: 0x0001, 0x5215: 0x0001, 0x5216: 0x0001, 0x5217: 0x0001, 0x5218: 0x0001, 0x5219: 0x0001, 0x521a: 0x0001, 0x521b: 0x0001, 0x521c: 0x0001, 0x521d: 0x0001, 0x521e: 0x0001, 0x521f: 0x0001, 0x5220: 0x0001, 0x5221: 0x0001, 0x5222: 0x0001, 0x5223: 0x0001, 0x5224: 0x0001, 0x5225: 0x0001, 0x5226: 0x0001, 0x5227: 0x0001, 0x5228: 0x0001, 0x5229: 0x0001, 0x522a: 0x0001, 0x522b: 0x0001, 0x522c: 0x0010, 0x522d: 0x0010, 0x522e: 0x0010, 0x522f: 0x0010, 0x5230: 0x8000, 0x5231: 0x8000, 0x5232: 0x8000, 0x5233: 0x8000, 0x5234: 0x8000, 0x5235: 0x8000, 0x5236: 0x8000, 0x5237: 0x8000, 0x5238: 0x8000, 0x5239: 0x8000, // Block 0x149, offset 0x5240 0x5250: 0x0001, 0x5251: 0x0001, 0x5252: 0x0001, 0x5253: 0x0001, 0x5254: 0x0001, 0x5255: 0x0001, 0x5256: 0x0001, 0x5257: 0x0001, 0x5258: 0x0001, 0x5259: 0x0001, 0x525a: 0x0001, 0x525b: 0x0001, 0x525c: 0x0001, 0x525d: 0x0001, 0x525e: 0x0001, 0x525f: 0x0001, 0x5260: 0x0001, 0x5261: 0x0001, 0x5262: 0x0001, 0x5263: 0x0001, 0x5264: 0x0001, 0x5265: 0x0001, 0x5266: 0x0001, 0x5267: 0x0001, 0x5268: 0x0001, 0x5269: 0x0001, 0x526a: 0x0001, 0x526b: 0x0001, 0x526c: 0x0001, 0x526d: 0x0001, 0x526e: 0x0010, 0x526f: 0x0010, 0x5270: 0x0001, 0x5271: 0x8000, 0x5272: 0x8000, 0x5273: 0x8000, 0x5274: 0x8000, 0x5275: 0x8000, 0x5276: 0x8000, 0x5277: 0x8000, 0x5278: 0x8000, 0x5279: 0x8000, 0x527a: 0x8000, // Block 0x14a, offset 0x5280 0x5280: 0x0001, 0x5281: 0x0001, 0x5282: 0x0001, 0x5283: 0x0001, 0x5284: 0x0001, 0x5285: 0x0001, 0x5286: 0x0001, 0x5287: 0x0001, 0x5288: 0x0001, 0x5289: 0x0001, 0x528a: 0x0001, 0x528b: 0x0001, 0x528c: 0x0001, 0x528d: 0x0001, 0x528e: 0x0001, 0x528f: 0x0001, 0x5290: 0x0001, 0x5291: 0x0001, 0x5292: 0x0001, 0x5293: 0x0001, 0x5294: 0x0001, 0x5295: 0x0001, 0x5296: 0x0001, 0x5297: 0x0001, 0x5298: 0x0001, 0x5299: 0x0001, 0x529a: 0x0001, 0x529b: 0x0001, 0x529c: 0x0001, 0x529d: 0x0001, 0x529e: 0x0001, 0x52a0: 0x0001, 0x52a1: 0x0001, 0x52a2: 0x0001, 0x52a3: 0x0010, 0x52a4: 0x0001, 0x52a5: 0x0001, 0x52a6: 0x0010, 0x52a7: 0x0001, 0x52a8: 0x0001, 0x52a9: 0x0001, 0x52aa: 0x0001, 0x52ab: 0x0001, 0x52ac: 0x0001, 0x52ad: 0x0001, 0x52ae: 0x0010, 0x52af: 0x0010, 0x52b0: 0x0001, 0x52b1: 0x0001, 0x52b2: 0x0001, 0x52b3: 0x0001, 0x52b4: 0x0001, 0x52b5: 0x0010, 0x52be: 0x0001, 0x52bf: 0x0001, // Block 0x14b, offset 0x52c0 0x52e0: 0x0001, 0x52e1: 0x0001, 0x52e2: 0x0001, 0x52e3: 0x0001, 0x52e4: 0x0001, 0x52e5: 0x0001, 0x52e6: 0x0001, 0x52e8: 0x0001, 0x52e9: 0x0001, 0x52ea: 0x0001, 0x52eb: 0x0001, 0x52ed: 0x0001, 0x52ee: 0x0001, 0x52f0: 0x0001, 0x52f1: 0x0001, 0x52f2: 0x0001, 0x52f3: 0x0001, 0x52f4: 0x0001, 0x52f5: 0x0001, 0x52f6: 0x0001, 0x52f7: 0x0001, 0x52f8: 0x0001, 0x52f9: 0x0001, 0x52fa: 0x0001, 0x52fb: 0x0001, 0x52fc: 0x0001, 0x52fd: 0x0001, 0x52fe: 0x0001, // Block 0x14c, offset 0x5300 0x5300: 0x0001, 0x5301: 0x0001, 0x5302: 0x0001, 0x5303: 0x0001, 0x5304: 0x0001, 0x5310: 0x0010, 0x5311: 0x0010, 0x5312: 0x0010, 0x5313: 0x0010, 0x5314: 0x0010, 0x5315: 0x0010, 0x5316: 0x0010, // Block 0x14d, offset 0x5340 0x5340: 0x0001, 0x5341: 0x0001, 0x5342: 0x0001, 0x5343: 0x0001, 0x5344: 0x0010, 0x5345: 0x0010, 0x5346: 0x0010, 0x5347: 0x0010, 0x5348: 0x0010, 0x5349: 0x0010, 0x534a: 0x0010, 0x534b: 0x0001, 0x5350: 0x8000, 0x5351: 0x8000, 0x5352: 0x8000, 0x5353: 0x8000, 0x5354: 0x8000, 0x5355: 0x8000, 0x5356: 0x8000, 0x5357: 0x8000, 0x5358: 0x8000, 0x5359: 0x8000, // Block 0x14e, offset 0x5380 0x5380: 0x0001, 0x5381: 0x0001, 0x5382: 0x0001, 0x5383: 0x0001, 0x5385: 0x0001, 0x5386: 0x0001, 0x5387: 0x0001, 0x5388: 0x0001, 0x5389: 0x0001, 0x538a: 0x0001, 0x538b: 0x0001, 0x538c: 0x0001, 0x538d: 0x0001, 0x538e: 0x0001, 0x538f: 0x0001, 0x5390: 0x0001, 0x5391: 0x0001, 0x5392: 0x0001, 0x5393: 0x0001, 0x5394: 0x0001, 0x5395: 0x0001, 0x5396: 0x0001, 0x5397: 0x0001, 0x5398: 0x0001, 0x5399: 0x0001, 0x539a: 0x0001, 0x539b: 0x0001, 0x539c: 0x0001, 0x539d: 0x0001, 0x539e: 0x0001, 0x539f: 0x0001, 0x53a1: 0x0001, 0x53a2: 0x0001, 0x53a4: 0x0001, 0x53a7: 0x0001, 0x53a9: 0x0001, 0x53aa: 0x0001, 0x53ab: 0x0001, 0x53ac: 0x0001, 0x53ad: 0x0001, 0x53ae: 0x0001, 0x53af: 0x0001, 0x53b0: 0x0001, 0x53b1: 0x0001, 0x53b2: 0x0001, 0x53b4: 0x0001, 0x53b5: 0x0001, 0x53b6: 0x0001, 0x53b7: 0x0001, 0x53b9: 0x0001, 0x53bb: 0x0001, // Block 0x14f, offset 0x53c0 0x53c2: 0x0001, 0x53c7: 0x0001, 0x53c9: 0x0001, 0x53cb: 0x0001, 0x53cd: 0x0001, 0x53ce: 0x0001, 0x53cf: 0x0001, 0x53d1: 0x0001, 0x53d2: 0x0001, 0x53d4: 0x0001, 0x53d7: 0x0001, 0x53d9: 0x0001, 0x53db: 0x0001, 0x53dd: 0x0001, 0x53df: 0x0001, 0x53e1: 0x0001, 0x53e2: 0x0001, 0x53e4: 0x0001, 0x53e7: 0x0001, 0x53e8: 0x0001, 0x53e9: 0x0001, 0x53ea: 0x0001, 0x53ec: 0x0001, 0x53ed: 0x0001, 0x53ee: 0x0001, 0x53ef: 0x0001, 0x53f0: 0x0001, 0x53f1: 0x0001, 0x53f2: 0x0001, 0x53f4: 0x0001, 0x53f5: 0x0001, 0x53f6: 0x0001, 0x53f7: 0x0001, 0x53f9: 0x0001, 0x53fa: 0x0001, 0x53fb: 0x0001, 0x53fc: 0x0001, 0x53fe: 0x0001, // Block 0x150, offset 0x5400 0x5400: 0x0001, 0x5401: 0x0001, 0x5402: 0x0001, 0x5403: 0x0001, 0x5404: 0x0001, 0x5405: 0x0001, 0x5406: 0x0001, 0x5407: 0x0001, 0x5408: 0x0001, 0x5409: 0x0001, 0x540b: 0x0001, 0x540c: 0x0001, 0x540d: 0x0001, 0x540e: 0x0001, 0x540f: 0x0001, 0x5410: 0x0001, 0x5411: 0x0001, 0x5412: 0x0001, 0x5413: 0x0001, 0x5414: 0x0001, 0x5415: 0x0001, 0x5416: 0x0001, 0x5417: 0x0001, 0x5418: 0x0001, 0x5419: 0x0001, 0x541a: 0x0001, 0x541b: 0x0001, 0x5421: 0x0001, 0x5422: 0x0001, 0x5423: 0x0001, 0x5425: 0x0001, 0x5426: 0x0001, 0x5427: 0x0001, 0x5428: 0x0001, 0x5429: 0x0001, 0x542b: 0x0001, 0x542c: 0x0001, 0x542d: 0x0001, 0x542e: 0x0001, 0x542f: 0x0001, 0x5430: 0x0001, 0x5431: 0x0001, 0x5432: 0x0001, 0x5433: 0x0001, 0x5434: 0x0001, 0x5435: 0x0001, 0x5436: 0x0001, 0x5437: 0x0001, 0x5438: 0x0001, 0x5439: 0x0001, 0x543a: 0x0001, 0x543b: 0x0001, // Block 0x151, offset 0x5440 0x5444: 0x0040, 0x546c: 0x0040, 0x546d: 0x0040, 0x546e: 0x0040, 0x546f: 0x0040, // Block 0x152, offset 0x5480 0x5494: 0x0040, 0x5495: 0x0040, 0x5496: 0x0040, 0x5497: 0x0040, 0x5498: 0x0040, 0x5499: 0x0040, 0x549a: 0x0040, 0x549b: 0x0040, 0x549c: 0x0040, 0x549d: 0x0040, 0x549e: 0x0040, 0x549f: 0x0040, 0x54af: 0x0040, 0x54b0: 0x0040, // Block 0x153, offset 0x54c0 0x54c0: 0x0040, 0x54cf: 0x0040, 0x54d0: 0x0040, 0x54f6: 0x0040, 0x54f7: 0x0040, 0x54f8: 0x0040, 0x54f9: 0x0040, 0x54fa: 0x0040, 0x54fb: 0x0040, 0x54fc: 0x0040, 0x54fd: 0x0040, 0x54fe: 0x0040, 0x54ff: 0x0040, // Block 0x154, offset 0x5500 0x5530: 0x0001, 0x5531: 0x0001, 0x5532: 0x0001, 0x5533: 0x0001, 0x5534: 0x0001, 0x5535: 0x0001, 0x5536: 0x0001, 0x5537: 0x0001, 0x5538: 0x0001, 0x5539: 0x0001, 0x553a: 0x0001, 0x553b: 0x0001, 0x553c: 0x0001, 0x553d: 0x0001, 0x553e: 0x0001, 0x553f: 0x0001, // Block 0x155, offset 0x5540 0x5540: 0x0001, 0x5541: 0x0001, 0x5542: 0x0001, 0x5543: 0x0001, 0x5544: 0x0001, 0x5545: 0x0001, 0x5546: 0x0001, 0x5547: 0x0001, 0x5548: 0x0001, 0x5549: 0x0001, 0x5550: 0x0001, 0x5551: 0x0001, 0x5552: 0x0001, 0x5553: 0x0001, 0x5554: 0x0001, 0x5555: 0x0001, 0x5556: 0x0001, 0x5557: 0x0001, 0x5558: 0x0001, 0x5559: 0x0001, 0x555a: 0x0001, 0x555b: 0x0001, 0x555c: 0x0001, 0x555d: 0x0001, 0x555e: 0x0001, 0x555f: 0x0001, 0x5560: 0x0001, 0x5561: 0x0001, 0x5562: 0x0001, 0x5563: 0x0001, 0x5564: 0x0001, 0x5565: 0x0001, 0x5566: 0x0001, 0x5567: 0x0001, 0x5568: 0x0001, 0x5569: 0x0001, 0x5570: 0x0041, 0x5571: 0x0041, 0x5572: 0x0001, 0x5573: 0x0001, 0x5574: 0x0001, 0x5575: 0x0001, 0x5576: 0x0001, 0x5577: 0x0001, 0x5578: 0x0001, 0x5579: 0x0001, 0x557a: 0x0001, 0x557b: 0x0001, 0x557c: 0x0001, 0x557d: 0x0001, 0x557e: 0x0041, 0x557f: 0x0041, // Block 0x156, offset 0x5580 0x5580: 0x0001, 0x5581: 0x0001, 0x5582: 0x0001, 0x5583: 0x0001, 0x5584: 0x0001, 0x5585: 0x0001, 0x5586: 0x0001, 0x5587: 0x0001, 0x5588: 0x0001, 0x5589: 0x0001, 0x558e: 0x0040, 0x5591: 0x0040, 0x5592: 0x0040, 0x5593: 0x0040, 0x5594: 0x0040, 0x5595: 0x0040, 0x5596: 0x0040, 0x5597: 0x0040, 0x5598: 0x0040, 0x5599: 0x0040, 0x559a: 0x0040, 0x55ae: 0x0040, 0x55af: 0x0040, 0x55b0: 0x0040, 0x55b1: 0x0040, 0x55b2: 0x0040, 0x55b3: 0x0040, 0x55b4: 0x0040, 0x55b5: 0x0040, 0x55b6: 0x0040, 0x55b7: 0x0040, 0x55b8: 0x0040, 0x55b9: 0x0040, 0x55ba: 0x0040, 0x55bb: 0x0040, 0x55bc: 0x0040, 0x55bd: 0x0040, 0x55be: 0x0040, 0x55bf: 0x0040, // Block 0x157, offset 0x55c0 0x55c0: 0x0040, 0x55c1: 0x0040, 0x55c2: 0x0040, 0x55c3: 0x0040, 0x55c4: 0x0040, 0x55c5: 0x0040, 0x55c6: 0x0040, 0x55c7: 0x0040, 0x55c8: 0x0040, 0x55c9: 0x0040, 0x55ca: 0x0040, 0x55cb: 0x0040, 0x55cc: 0x0040, 0x55cd: 0x0040, 0x55ce: 0x0040, 0x55cf: 0x0040, 0x55d0: 0x0040, 0x55d1: 0x0040, 0x55d2: 0x0040, 0x55d3: 0x0040, 0x55d4: 0x0040, 0x55d5: 0x0040, 0x55d6: 0x0040, 0x55d7: 0x0040, 0x55d8: 0x0040, 0x55d9: 0x0040, 0x55da: 0x0040, 0x55db: 0x0040, 0x55dc: 0x0040, 0x55dd: 0x0040, 0x55de: 0x0040, 0x55df: 0x0040, 0x55e0: 0x0040, 0x55e1: 0x0040, 0x55e2: 0x0040, 0x55e3: 0x0040, 0x55e4: 0x0040, 0x55e5: 0x0040, 0x55e6: 0x10000, 0x55e7: 0x10000, 0x55e8: 0x10000, 0x55e9: 0x10000, 0x55ea: 0x10000, 0x55eb: 0x10000, 0x55ec: 0x10000, 0x55ed: 0x10000, 0x55ee: 0x10000, 0x55ef: 0x10000, 0x55f0: 0x10000, 0x55f1: 0x10000, 0x55f2: 0x10000, 0x55f3: 0x10000, 0x55f4: 0x10000, 0x55f5: 0x10000, 0x55f6: 0x10000, 0x55f7: 0x10000, 0x55f8: 0x10000, 0x55f9: 0x10000, 0x55fa: 0x10000, 0x55fb: 0x10000, 0x55fc: 0x10000, 0x55fd: 0x10000, 0x55fe: 0x10000, 0x55ff: 0x10000, // Block 0x158, offset 0x5600 0x5600: 0x0002, 0x5601: 0x0040, 0x5602: 0x0040, 0x5603: 0x0040, 0x5604: 0x0040, 0x5605: 0x0040, 0x5606: 0x0040, 0x5607: 0x0040, 0x5608: 0x0040, 0x5609: 0x0040, 0x560a: 0x0040, 0x560b: 0x0040, 0x560c: 0x0040, 0x560d: 0x0040, 0x560e: 0x0040, 0x560f: 0x0040, 0x561a: 0x0040, 0x562f: 0x0040, 0x5632: 0x0040, 0x5633: 0x0040, 0x5634: 0x0040, 0x5635: 0x0040, 0x5636: 0x0040, 0x5637: 0x0040, 0x5638: 0x0040, 0x5639: 0x0040, 0x563a: 0x0040, 0x563c: 0x0040, 0x563d: 0x0040, 0x563e: 0x0040, 0x563f: 0x0040, // Block 0x159, offset 0x5640 0x5649: 0x0040, 0x564a: 0x0040, 0x564b: 0x0040, 0x564c: 0x0040, 0x564d: 0x0040, 0x564e: 0x0040, 0x564f: 0x0040, 0x5650: 0x0040, 0x5651: 0x0040, 0x5652: 0x0040, 0x5653: 0x0040, 0x5654: 0x0040, 0x5655: 0x0040, 0x5656: 0x0040, 0x5657: 0x0040, 0x5658: 0x0040, 0x5659: 0x0040, 0x565a: 0x0040, 0x565b: 0x0040, 0x565c: 0x0040, 0x565d: 0x0040, 0x565e: 0x0040, 0x565f: 0x0040, 0x5666: 0x0040, 0x5667: 0x0040, 0x5668: 0x0040, 0x5669: 0x0040, 0x566a: 0x0040, 0x566b: 0x0040, 0x566c: 0x0040, 0x566d: 0x0040, 0x566e: 0x0040, 0x566f: 0x0040, 0x5670: 0x0040, 0x5671: 0x0040, 0x5672: 0x0040, 0x5673: 0x0040, 0x5674: 0x0040, 0x5675: 0x0040, 0x5676: 0x0040, 0x5677: 0x0040, 0x5678: 0x0040, 0x5679: 0x0040, 0x567a: 0x0040, 0x567b: 0x0040, 0x567c: 0x0040, 0x567d: 0x0040, 0x567e: 0x0040, 0x567f: 0x0040, // Block 0x15a, offset 0x5680 0x5680: 0x0040, 0x5681: 0x0040, 0x5682: 0x0040, 0x5683: 0x0040, 0x5684: 0x0040, 0x5685: 0x0040, 0x5686: 0x0040, 0x5687: 0x0040, 0x5688: 0x0040, 0x5689: 0x0040, 0x568a: 0x0040, 0x568b: 0x0040, 0x568c: 0x0040, 0x568d: 0x0040, 0x568e: 0x0040, 0x568f: 0x0040, 0x5690: 0x0040, 0x5691: 0x0040, 0x5692: 0x0040, 0x5693: 0x0040, 0x5694: 0x0040, 0x5695: 0x0040, 0x5696: 0x0040, 0x5697: 0x0040, 0x5698: 0x0040, 0x5699: 0x0040, 0x569a: 0x0040, 0x569b: 0x0040, 0x569c: 0x0040, 0x569d: 0x0040, 0x569e: 0x0040, 0x569f: 0x0040, 0x56a0: 0x0040, 0x56a1: 0x0040, 0x56a2: 0x0040, 0x56a3: 0x0040, 0x56a4: 0x0040, 0x56a5: 0x0040, 0x56a6: 0x0040, 0x56a7: 0x0040, 0x56a8: 0x0040, 0x56a9: 0x0040, 0x56aa: 0x0040, 0x56ab: 0x0040, 0x56ac: 0x0040, 0x56ad: 0x0040, 0x56ae: 0x0040, 0x56af: 0x0040, 0x56b0: 0x0040, 0x56b1: 0x0040, 0x56b2: 0x0040, 0x56b3: 0x0040, 0x56b4: 0x0040, 0x56b5: 0x0040, 0x56b6: 0x0040, 0x56b7: 0x0040, 0x56b8: 0x0040, 0x56b9: 0x0040, 0x56ba: 0x0040, 0x56bb: 0x0040, 0x56bc: 0x0040, 0x56bd: 0x0040, 0x56be: 0x0040, 0x56bf: 0x0040, // Block 0x15b, offset 0x56c0 0x56c0: 0x0040, 0x56c1: 0x0040, 0x56c2: 0x0040, 0x56c3: 0x0040, 0x56c4: 0x0040, 0x56c5: 0x0040, 0x56c6: 0x0040, 0x56c7: 0x0040, 0x56c8: 0x0040, 0x56c9: 0x0040, 0x56ca: 0x0040, 0x56cb: 0x0040, 0x56cc: 0x0040, 0x56cd: 0x0040, 0x56ce: 0x0040, 0x56cf: 0x0040, 0x56d0: 0x0040, 0x56d1: 0x0040, 0x56d2: 0x0040, 0x56d3: 0x0040, 0x56d4: 0x0040, 0x56d5: 0x0040, 0x56d6: 0x0040, 0x56d7: 0x0040, 0x56d8: 0x0040, 0x56d9: 0x0040, 0x56da: 0x0040, 0x56db: 0x0040, 0x56dc: 0x0040, 0x56dd: 0x0040, 0x56de: 0x0040, 0x56df: 0x0040, 0x56e0: 0x0040, 0x56e1: 0x0040, 0x56e4: 0x0040, 0x56e5: 0x0040, 0x56e6: 0x0040, 0x56e7: 0x0040, 0x56e8: 0x0040, 0x56e9: 0x0040, 0x56ea: 0x0040, 0x56eb: 0x0040, 0x56ec: 0x0040, 0x56ed: 0x0040, 0x56ee: 0x0040, 0x56ef: 0x0040, 0x56f0: 0x0040, 0x56f1: 0x0040, 0x56f2: 0x0040, 0x56f3: 0x0040, 0x56f4: 0x0040, 0x56f5: 0x0040, 0x56f6: 0x0040, 0x56f7: 0x0040, 0x56f8: 0x0040, 0x56f9: 0x0040, 0x56fa: 0x0040, 0x56fb: 0x0040, 0x56fc: 0x0040, 0x56fd: 0x0040, 0x56fe: 0x0040, 0x56ff: 0x0040, // Block 0x15c, offset 0x5700 0x5700: 0x0040, 0x5701: 0x0040, 0x5702: 0x0040, 0x5703: 0x0040, 0x5704: 0x0040, 0x5705: 0x0040, 0x5706: 0x0040, 0x5707: 0x0040, 0x5708: 0x0040, 0x5709: 0x0040, 0x570a: 0x0040, 0x570b: 0x0040, 0x570c: 0x0040, 0x570d: 0x0040, 0x570e: 0x0040, 0x570f: 0x0040, 0x5710: 0x0040, 0x5711: 0x0040, 0x5712: 0x0040, 0x5713: 0x0040, 0x5716: 0x0040, 0x5717: 0x0040, 0x5719: 0x0040, 0x571a: 0x0040, 0x571b: 0x0040, 0x571e: 0x0040, 0x571f: 0x0040, 0x5720: 0x0040, 0x5721: 0x0040, 0x5722: 0x0040, 0x5723: 0x0040, 0x5724: 0x0040, 0x5725: 0x0040, 0x5726: 0x0040, 0x5727: 0x0040, 0x5728: 0x0040, 0x5729: 0x0040, 0x572a: 0x0040, 0x572b: 0x0040, 0x572c: 0x0040, 0x572d: 0x0040, 0x572e: 0x0040, 0x572f: 0x0040, 0x5730: 0x0040, 0x5731: 0x0040, 0x5732: 0x0040, 0x5733: 0x0040, 0x5734: 0x0040, 0x5735: 0x0040, 0x5736: 0x0040, 0x5737: 0x0040, 0x5738: 0x0040, 0x5739: 0x0040, 0x573a: 0x0040, 0x573b: 0x0040, 0x573c: 0x0040, 0x573d: 0x0040, 0x573e: 0x0040, 0x573f: 0x0040, // Block 0x15d, offset 0x5740 0x5740: 0x0040, 0x5741: 0x0040, 0x5742: 0x0040, 0x5743: 0x0040, 0x5744: 0x0040, 0x5745: 0x0040, 0x5746: 0x0040, 0x5747: 0x0040, 0x5748: 0x0040, 0x5749: 0x0040, 0x574a: 0x0040, 0x574b: 0x0040, 0x574c: 0x0040, 0x574d: 0x0040, 0x574e: 0x0040, 0x574f: 0x0040, 0x5750: 0x0040, 0x5751: 0x0040, 0x5752: 0x0040, 0x5753: 0x0040, 0x5754: 0x0040, 0x5755: 0x0040, 0x5756: 0x0040, 0x5757: 0x0040, 0x5758: 0x0040, 0x5759: 0x0040, 0x575a: 0x0040, 0x575b: 0x0040, 0x575c: 0x0040, 0x575d: 0x0040, 0x575e: 0x0040, 0x575f: 0x0040, 0x5760: 0x0040, 0x5761: 0x0040, 0x5762: 0x0040, 0x5763: 0x0040, 0x5764: 0x0040, 0x5765: 0x0040, 0x5766: 0x0040, 0x5767: 0x0040, 0x5768: 0x0040, 0x5769: 0x0040, 0x576a: 0x0040, 0x576b: 0x0040, 0x576c: 0x0040, 0x576d: 0x0040, 0x576e: 0x0040, 0x576f: 0x0040, 0x5770: 0x0040, 0x5773: 0x0040, 0x5774: 0x0040, 0x5775: 0x0040, 0x5777: 0x0040, 0x5778: 0x0040, 0x5779: 0x0040, 0x577a: 0x0040, 0x577b: 0x0010, 0x577c: 0x0010, 0x577d: 0x0010, 0x577e: 0x0010, 0x577f: 0x0010, // Block 0x15e, offset 0x5780 0x5780: 0x0040, 0x5781: 0x0040, 0x5782: 0x0040, 0x5783: 0x0040, 0x5784: 0x0040, 0x5785: 0x0040, 0x5786: 0x0040, 0x5787: 0x0040, 0x5788: 0x0040, 0x5789: 0x0040, 0x578a: 0x0040, 0x578b: 0x0040, 0x578c: 0x0040, 0x578d: 0x0040, 0x578e: 0x0040, 0x578f: 0x0040, 0x5790: 0x0040, 0x5791: 0x0040, 0x5792: 0x0040, 0x5793: 0x0040, 0x5794: 0x0040, 0x5795: 0x0040, 0x5796: 0x0040, 0x5797: 0x0040, 0x5798: 0x0040, 0x5799: 0x0040, 0x579a: 0x0040, 0x579b: 0x0040, 0x579c: 0x0040, 0x579d: 0x0040, 0x579e: 0x0040, 0x579f: 0x0040, 0x57a0: 0x0040, 0x57a1: 0x0040, 0x57a2: 0x0040, 0x57a3: 0x0040, 0x57a4: 0x0040, 0x57a5: 0x0040, 0x57a6: 0x0040, 0x57a7: 0x0040, 0x57a8: 0x0040, 0x57a9: 0x0040, 0x57aa: 0x0040, 0x57ab: 0x0040, 0x57ac: 0x0040, 0x57ad: 0x0040, 0x57ae: 0x0040, 0x57af: 0x0040, 0x57b0: 0x0040, 0x57b1: 0x0040, 0x57b2: 0x0040, 0x57b3: 0x0040, 0x57b4: 0x0040, 0x57b5: 0x0040, 0x57b6: 0x0040, 0x57b7: 0x0040, 0x57b8: 0x0040, 0x57b9: 0x0040, 0x57ba: 0x0040, 0x57bb: 0x0040, 0x57bc: 0x0040, 0x57bd: 0x0040, 0x57bf: 0x0040, // Block 0x15f, offset 0x57c0 0x57c0: 0x0040, 0x57c1: 0x0040, 0x57c2: 0x0040, 0x57c3: 0x0040, 0x57c4: 0x0040, 0x57c5: 0x0040, 0x57c6: 0x0040, 0x57c7: 0x0040, 0x57c8: 0x0040, 0x57c9: 0x0040, 0x57ca: 0x0040, 0x57cb: 0x0040, 0x57cc: 0x0040, 0x57cd: 0x0040, 0x57ce: 0x0040, 0x57cf: 0x0040, 0x57d0: 0x0040, 0x57d1: 0x0040, 0x57d2: 0x0040, 0x57d3: 0x0040, 0x57d4: 0x0040, 0x57d5: 0x0040, 0x57d6: 0x0040, 0x57d7: 0x0040, 0x57d8: 0x0040, 0x57d9: 0x0040, 0x57da: 0x0040, 0x57db: 0x0040, 0x57dc: 0x0040, 0x57dd: 0x0040, 0x57de: 0x0040, 0x57df: 0x0040, 0x57e0: 0x0040, 0x57e1: 0x0040, 0x57e2: 0x0040, 0x57e3: 0x0040, 0x57e4: 0x0040, 0x57e5: 0x0040, 0x57e6: 0x0040, 0x57e7: 0x0040, 0x57e8: 0x0040, 0x57e9: 0x0040, 0x57ea: 0x0040, 0x57eb: 0x0040, 0x57ec: 0x0040, 0x57ed: 0x0040, 0x57ee: 0x0040, 0x57ef: 0x0040, 0x57f0: 0x0040, 0x57f1: 0x0040, 0x57f2: 0x0040, 0x57f3: 0x0040, 0x57f4: 0x0040, 0x57f5: 0x0040, 0x57f6: 0x0040, 0x57f7: 0x0040, 0x57f8: 0x0040, 0x57f9: 0x0040, 0x57fa: 0x0040, 0x57fb: 0x0040, 0x57fc: 0x0040, 0x57fd: 0x0040, // Block 0x160, offset 0x5800 0x5809: 0x0040, 0x580a: 0x0040, 0x580b: 0x0040, 0x580c: 0x0040, 0x580d: 0x0040, 0x580e: 0x0040, 0x5810: 0x0040, 0x5811: 0x0040, 0x5812: 0x0040, 0x5813: 0x0040, 0x5814: 0x0040, 0x5815: 0x0040, 0x5816: 0x0040, 0x5817: 0x0040, 0x5818: 0x0040, 0x5819: 0x0040, 0x581a: 0x0040, 0x581b: 0x0040, 0x581c: 0x0040, 0x581d: 0x0040, 0x581e: 0x0040, 0x581f: 0x0040, 0x5820: 0x0040, 0x5821: 0x0040, 0x5822: 0x0040, 0x5823: 0x0040, 0x5824: 0x0040, 0x5825: 0x0040, 0x5826: 0x0040, 0x5827: 0x0040, 0x582f: 0x0040, 0x5830: 0x0040, 0x5833: 0x0040, 0x5834: 0x0040, 0x5835: 0x0040, 0x5836: 0x0040, 0x5837: 0x0040, 0x5838: 0x0040, 0x5839: 0x0040, 0x583a: 0x0040, // Block 0x161, offset 0x5840 0x5847: 0x0040, 0x584a: 0x0040, 0x584b: 0x0040, 0x584c: 0x0040, 0x584d: 0x0040, 0x5850: 0x0040, 0x5855: 0x0040, 0x5856: 0x0040, 0x5864: 0x0040, 0x5865: 0x0040, 0x5868: 0x0040, 0x5871: 0x0040, 0x5872: 0x0040, 0x587c: 0x0040, // Block 0x162, offset 0x5880 0x5882: 0x0040, 0x5883: 0x0040, 0x5884: 0x0040, 0x5891: 0x0040, 0x5892: 0x0040, 0x5893: 0x0040, 0x589c: 0x0040, 0x589d: 0x0040, 0x589e: 0x0040, 0x58a1: 0x0040, 0x58a3: 0x0040, 0x58a8: 0x0040, 0x58af: 0x0040, 0x58b3: 0x0040, 0x58ba: 0x0040, 0x58bb: 0x0040, 0x58bc: 0x0040, 0x58bd: 0x0040, 0x58be: 0x0040, 0x58bf: 0x0040, // Block 0x163, offset 0x58c0 0x58c0: 0x0040, 0x58c1: 0x0040, 0x58c2: 0x0040, 0x58c3: 0x0040, 0x58c4: 0x0040, 0x58c5: 0x0040, 0x58c6: 0x0040, 0x58c7: 0x0040, 0x58c8: 0x0040, 0x58c9: 0x0040, 0x58ca: 0x0040, 0x58cb: 0x0040, 0x58cc: 0x0040, 0x58cd: 0x0040, 0x58ce: 0x0040, 0x58cf: 0x0040, // Block 0x164, offset 0x5900 0x5900: 0x0040, 0x5901: 0x0040, 0x5902: 0x0040, 0x5903: 0x0040, 0x5904: 0x0040, 0x5905: 0x0040, 0x590b: 0x0040, 0x590c: 0x0040, 0x590d: 0x0040, 0x590e: 0x0040, 0x590f: 0x0040, 0x5910: 0x0040, 0x5911: 0x0040, 0x5912: 0x0040, 0x5915: 0x0040, 0x5916: 0x0040, 0x5917: 0x0040, 0x5918: 0x0040, 0x5919: 0x0040, 0x591a: 0x0040, 0x591b: 0x0040, 0x591c: 0x0040, 0x591d: 0x0040, 0x591e: 0x0040, 0x591f: 0x0040, 0x5920: 0x0040, 0x5921: 0x0040, 0x5922: 0x0040, 0x5923: 0x0040, 0x5924: 0x0040, 0x5925: 0x0040, 0x5929: 0x0040, 0x592b: 0x0040, 0x592c: 0x0040, 0x592d: 0x0040, 0x592e: 0x0040, 0x592f: 0x0040, 0x5930: 0x0040, 0x5933: 0x0040, 0x5934: 0x0040, 0x5935: 0x0040, 0x5936: 0x0040, 0x5937: 0x0040, 0x5938: 0x0040, 0x5939: 0x0040, 0x593a: 0x0040, 0x593b: 0x0040, 0x593c: 0x0040, 0x593d: 0x0040, 0x593e: 0x0040, 0x593f: 0x0040, // Block 0x165, offset 0x5940 0x595a: 0x0040, 0x595b: 0x0040, 0x595c: 0x0040, 0x595d: 0x0040, 0x595e: 0x0040, 0x595f: 0x0040, 0x5960: 0x0040, 0x5961: 0x0040, 0x5962: 0x0040, 0x5963: 0x0040, 0x5964: 0x0040, 0x5965: 0x0040, 0x5966: 0x0040, 0x5967: 0x0040, 0x5968: 0x0040, 0x5969: 0x0040, 0x596a: 0x0040, 0x596b: 0x0040, 0x596c: 0x0040, 0x596d: 0x0040, 0x596e: 0x0040, 0x596f: 0x0040, 0x5970: 0x0040, 0x5971: 0x0040, 0x5972: 0x0040, 0x5973: 0x0040, 0x5974: 0x0040, 0x5975: 0x0040, 0x5976: 0x0040, 0x5977: 0x0040, 0x5978: 0x0040, 0x5979: 0x0040, 0x597a: 0x0040, 0x597b: 0x0040, 0x597c: 0x0040, 0x597d: 0x0040, 0x597e: 0x0040, 0x597f: 0x0040, // Block 0x166, offset 0x5980 0x598c: 0x0040, 0x598d: 0x0040, 0x598e: 0x0040, 0x598f: 0x0040, // Block 0x167, offset 0x59c0 0x59c8: 0x0040, 0x59c9: 0x0040, 0x59ca: 0x0040, 0x59cb: 0x0040, 0x59cc: 0x0040, 0x59cd: 0x0040, 0x59ce: 0x0040, 0x59cf: 0x0040, 0x59da: 0x0040, 0x59db: 0x0040, 0x59dc: 0x0040, 0x59dd: 0x0040, 0x59de: 0x0040, 0x59df: 0x0040, // Block 0x168, offset 0x5a00 0x5a08: 0x0040, 0x5a09: 0x0040, 0x5a0a: 0x0040, 0x5a0b: 0x0040, 0x5a0c: 0x0040, 0x5a0d: 0x0040, 0x5a0e: 0x0040, 0x5a0f: 0x0040, 0x5a2e: 0x0040, 0x5a2f: 0x0040, 0x5a3c: 0x0040, 0x5a3d: 0x0040, 0x5a3e: 0x0040, 0x5a3f: 0x0040, // Block 0x169, offset 0x5a40 0x5a42: 0x0040, 0x5a43: 0x0040, 0x5a44: 0x0040, 0x5a45: 0x0040, 0x5a46: 0x0040, 0x5a47: 0x0040, 0x5a48: 0x0040, 0x5a49: 0x0040, 0x5a4a: 0x0040, 0x5a4b: 0x0040, 0x5a4c: 0x0040, 0x5a4d: 0x0040, 0x5a4e: 0x0040, 0x5a4f: 0x0040, 0x5a59: 0x0040, 0x5a5a: 0x0040, 0x5a5b: 0x0040, 0x5a5c: 0x0040, 0x5a5d: 0x0040, 0x5a5e: 0x0040, 0x5a5f: 0x0040, 0x5a60: 0x0040, 0x5a61: 0x0040, 0x5a62: 0x0040, 0x5a63: 0x0040, 0x5a64: 0x0040, 0x5a65: 0x0040, 0x5a66: 0x0040, 0x5a67: 0x0040, 0x5a68: 0x0040, 0x5a69: 0x0040, 0x5a6a: 0x0040, 0x5a6b: 0x0040, 0x5a6c: 0x0040, 0x5a6d: 0x0040, 0x5a6e: 0x0040, 0x5a6f: 0x0040, 0x5a70: 0x0040, 0x5a71: 0x0040, 0x5a72: 0x0040, 0x5a73: 0x0040, 0x5a74: 0x0040, 0x5a75: 0x0040, 0x5a76: 0x0040, 0x5a77: 0x0040, 0x5a78: 0x0040, 0x5a79: 0x0040, 0x5a7a: 0x0040, 0x5a7b: 0x0040, 0x5a7c: 0x0040, 0x5a7d: 0x0040, 0x5a7e: 0x0040, 0x5a7f: 0x0040, // Block 0x16a, offset 0x5a80 0x5a8c: 0x0040, 0x5a8d: 0x0040, 0x5a8e: 0x0040, 0x5a8f: 0x0040, 0x5a90: 0x0040, 0x5a91: 0x0040, 0x5a92: 0x0040, 0x5a93: 0x0040, 0x5a94: 0x0040, 0x5a95: 0x0040, 0x5a96: 0x0040, 0x5a97: 0x0040, 0x5a98: 0x0040, 0x5a99: 0x0040, 0x5a9a: 0x0040, 0x5a9b: 0x0040, 0x5a9c: 0x0040, 0x5a9d: 0x0040, 0x5a9e: 0x0040, 0x5a9f: 0x0040, 0x5aa0: 0x0040, 0x5aa1: 0x0040, 0x5aa2: 0x0040, 0x5aa3: 0x0040, 0x5aa4: 0x0040, 0x5aa5: 0x0040, 0x5aa6: 0x0040, 0x5aa7: 0x0040, 0x5aa8: 0x0040, 0x5aa9: 0x0040, 0x5aaa: 0x0040, 0x5aab: 0x0040, 0x5aac: 0x0040, 0x5aad: 0x0040, 0x5aae: 0x0040, 0x5aaf: 0x0040, 0x5ab0: 0x0040, 0x5ab1: 0x0040, 0x5ab2: 0x0040, 0x5ab3: 0x0040, 0x5ab4: 0x0040, 0x5ab5: 0x0040, 0x5ab6: 0x0040, 0x5ab7: 0x0040, 0x5ab8: 0x0040, 0x5ab9: 0x0040, 0x5aba: 0x0040, 0x5abc: 0x0040, 0x5abd: 0x0040, 0x5abe: 0x0040, 0x5abf: 0x0040, // Block 0x16b, offset 0x5ac0 0x5ac0: 0x0040, 0x5ac1: 0x0040, 0x5ac2: 0x0040, 0x5ac3: 0x0040, 0x5ac4: 0x0040, 0x5ac5: 0x0040, 0x5ac7: 0x0040, 0x5ac8: 0x0040, 0x5ac9: 0x0040, 0x5aca: 0x0040, 0x5acb: 0x0040, 0x5acc: 0x0040, 0x5acd: 0x0040, 0x5ace: 0x0040, 0x5acf: 0x0040, 0x5ad0: 0x0040, 0x5ad1: 0x0040, 0x5ad2: 0x0040, 0x5ad3: 0x0040, 0x5ad4: 0x0040, 0x5ad5: 0x0040, 0x5ad6: 0x0040, 0x5ad7: 0x0040, 0x5ad8: 0x0040, 0x5ad9: 0x0040, 0x5ada: 0x0040, 0x5adb: 0x0040, 0x5adc: 0x0040, 0x5add: 0x0040, 0x5ade: 0x0040, 0x5adf: 0x0040, 0x5ae0: 0x0040, 0x5ae1: 0x0040, 0x5ae2: 0x0040, 0x5ae3: 0x0040, 0x5ae4: 0x0040, 0x5ae5: 0x0040, 0x5ae6: 0x0040, 0x5ae7: 0x0040, 0x5ae8: 0x0040, 0x5ae9: 0x0040, 0x5aea: 0x0040, 0x5aeb: 0x0040, 0x5aec: 0x0040, 0x5aed: 0x0040, 0x5aee: 0x0040, 0x5aef: 0x0040, 0x5af0: 0x0040, 0x5af1: 0x0040, 0x5af2: 0x0040, 0x5af3: 0x0040, 0x5af4: 0x0040, 0x5af5: 0x0040, 0x5af6: 0x0040, 0x5af7: 0x0040, 0x5af8: 0x0040, 0x5af9: 0x0040, 0x5afa: 0x0040, 0x5afb: 0x0040, 0x5afc: 0x0040, 0x5afd: 0x0040, 0x5afe: 0x0040, 0x5aff: 0x0040, // Block 0x16c, offset 0x5b00 0x5b18: 0x0040, 0x5b19: 0x0040, 0x5b1a: 0x0040, 0x5b1b: 0x0040, 0x5b1c: 0x0040, 0x5b1d: 0x0040, 0x5b1e: 0x0040, 0x5b1f: 0x0040, 0x5b2e: 0x0040, 0x5b2f: 0x0040, 0x5b30: 0x0040, 0x5b31: 0x0040, 0x5b32: 0x0040, 0x5b33: 0x0040, 0x5b34: 0x0040, 0x5b35: 0x0040, 0x5b36: 0x0040, 0x5b37: 0x0040, 0x5b38: 0x0040, 0x5b39: 0x0040, 0x5b3a: 0x0040, 0x5b3b: 0x0040, 0x5b3c: 0x0040, 0x5b3d: 0x0040, 0x5b3e: 0x0040, 0x5b3f: 0x0040, // Block 0x16d, offset 0x5b40 0x5b40: 0x0002, 0x5b41: 0x0002, 0x5b42: 0x0002, 0x5b43: 0x0002, 0x5b44: 0x0002, 0x5b45: 0x0002, 0x5b46: 0x0002, 0x5b47: 0x0002, 0x5b48: 0x0002, 0x5b49: 0x0002, 0x5b4a: 0x0002, 0x5b4b: 0x0002, 0x5b4c: 0x0002, 0x5b4d: 0x0002, 0x5b4e: 0x0002, 0x5b4f: 0x0002, 0x5b50: 0x0002, 0x5b51: 0x0002, 0x5b52: 0x0002, 0x5b53: 0x0002, 0x5b54: 0x0002, 0x5b55: 0x0002, 0x5b56: 0x0002, 0x5b57: 0x0002, 0x5b58: 0x0002, 0x5b59: 0x0002, 0x5b5a: 0x0002, 0x5b5b: 0x0002, 0x5b5c: 0x0002, 0x5b5d: 0x0002, 0x5b5e: 0x0002, 0x5b5f: 0x0002, // Block 0x16e, offset 0x5b80 0x5b80: 0x0002, 0x5b81: 0x0002, 0x5b82: 0x0002, 0x5b83: 0x0002, 0x5b84: 0x0002, 0x5b85: 0x0002, 0x5b86: 0x0002, 0x5b87: 0x0002, 0x5b88: 0x0002, 0x5b89: 0x0002, 0x5b8a: 0x0002, 0x5b8b: 0x0002, 0x5b8c: 0x0002, 0x5b8d: 0x0002, 0x5b8e: 0x0002, 0x5b8f: 0x0002, 0x5b90: 0x0002, 0x5b91: 0x0002, 0x5b92: 0x0002, 0x5b93: 0x0002, 0x5b94: 0x0002, 0x5b95: 0x0002, 0x5b96: 0x0002, 0x5b97: 0x0002, 0x5b98: 0x0002, 0x5b99: 0x0002, 0x5b9a: 0x0002, 0x5b9b: 0x0002, 0x5b9c: 0x0002, 0x5b9d: 0x0002, 0x5b9e: 0x0002, 0x5b9f: 0x0002, 0x5ba0: 0x0002, 0x5ba1: 0x0002, 0x5ba2: 0x0002, 0x5ba3: 0x0002, 0x5ba4: 0x0002, 0x5ba5: 0x0002, 0x5ba6: 0x0002, 0x5ba7: 0x0002, 0x5ba8: 0x0002, 0x5ba9: 0x0002, 0x5baa: 0x0002, 0x5bab: 0x0002, 0x5bac: 0x0002, 0x5bad: 0x0002, 0x5bae: 0x0002, 0x5baf: 0x0002, 0x5bb0: 0x0002, 0x5bb1: 0x0002, 0x5bb2: 0x0002, 0x5bb3: 0x0002, 0x5bb4: 0x0002, 0x5bb5: 0x0002, 0x5bb6: 0x0002, 0x5bb7: 0x0002, 0x5bb8: 0x0002, 0x5bb9: 0x0002, // Block 0x16f, offset 0x5bc0 0x5bc0: 0x0002, 0x5bc1: 0x0002, 0x5bc2: 0x0002, 0x5bc3: 0x0002, 0x5bc4: 0x0002, 0x5bc5: 0x0002, 0x5bc6: 0x0002, 0x5bc7: 0x0002, 0x5bc8: 0x0002, 0x5bc9: 0x0002, 0x5bca: 0x0002, 0x5bcb: 0x0002, 0x5bcc: 0x0002, 0x5bcd: 0x0002, 0x5bce: 0x0002, 0x5bcf: 0x0002, 0x5bd0: 0x0002, 0x5bd1: 0x0002, 0x5bd2: 0x0002, 0x5bd3: 0x0002, 0x5bd4: 0x0002, 0x5bd5: 0x0002, 0x5bd6: 0x0002, 0x5bd7: 0x0002, 0x5bd8: 0x0002, 0x5bd9: 0x0002, 0x5bda: 0x0002, 0x5bdb: 0x0002, 0x5bdc: 0x0002, 0x5bdd: 0x0002, 0x5be0: 0x0002, 0x5be1: 0x0002, 0x5be2: 0x0002, 0x5be3: 0x0002, 0x5be4: 0x0002, 0x5be5: 0x0002, 0x5be6: 0x0002, 0x5be7: 0x0002, 0x5be8: 0x0002, 0x5be9: 0x0002, 0x5bea: 0x0002, 0x5beb: 0x0002, 0x5bec: 0x0002, 0x5bed: 0x0002, 0x5bee: 0x0002, 0x5bef: 0x0002, 0x5bf0: 0x0002, 0x5bf1: 0x0002, 0x5bf2: 0x0002, 0x5bf3: 0x0002, 0x5bf4: 0x0002, 0x5bf5: 0x0002, 0x5bf6: 0x0002, 0x5bf7: 0x0002, 0x5bf8: 0x0002, 0x5bf9: 0x0002, 0x5bfa: 0x0002, 0x5bfb: 0x0002, 0x5bfc: 0x0002, 0x5bfd: 0x0002, 0x5bfe: 0x0002, 0x5bff: 0x0002, // Block 0x170, offset 0x5c00 0x5c00: 0x0002, 0x5c01: 0x0002, 0x5c02: 0x0002, 0x5c03: 0x0002, 0x5c04: 0x0002, 0x5c05: 0x0002, 0x5c06: 0x0002, 0x5c07: 0x0002, 0x5c08: 0x0002, 0x5c09: 0x0002, 0x5c0a: 0x0002, 0x5c0b: 0x0002, 0x5c0c: 0x0002, 0x5c0d: 0x0002, 0x5c0e: 0x0002, 0x5c0f: 0x0002, 0x5c10: 0x0002, 0x5c11: 0x0002, 0x5c12: 0x0002, 0x5c13: 0x0002, 0x5c14: 0x0002, 0x5c15: 0x0002, 0x5c16: 0x0002, 0x5c17: 0x0002, 0x5c18: 0x0002, 0x5c19: 0x0002, 0x5c1a: 0x0002, 0x5c1b: 0x0002, 0x5c1c: 0x0002, 0x5c1d: 0x0002, 0x5c1e: 0x0002, 0x5c1f: 0x0002, 0x5c20: 0x0002, 0x5c21: 0x0002, 0x5c30: 0x0002, 0x5c31: 0x0002, 0x5c32: 0x0002, 0x5c33: 0x0002, 0x5c34: 0x0002, 0x5c35: 0x0002, 0x5c36: 0x0002, 0x5c37: 0x0002, 0x5c38: 0x0002, 0x5c39: 0x0002, 0x5c3a: 0x0002, 0x5c3b: 0x0002, 0x5c3c: 0x0002, 0x5c3d: 0x0002, 0x5c3e: 0x0002, 0x5c3f: 0x0002, // Block 0x171, offset 0x5c40 0x5c40: 0x0002, 0x5c41: 0x0002, 0x5c42: 0x0002, 0x5c43: 0x0002, 0x5c44: 0x0002, 0x5c45: 0x0002, 0x5c46: 0x0002, 0x5c47: 0x0002, 0x5c48: 0x0002, 0x5c49: 0x0002, 0x5c4a: 0x0002, 0x5c4b: 0x0002, 0x5c4c: 0x0002, 0x5c4d: 0x0002, 0x5c4e: 0x0002, 0x5c4f: 0x0002, 0x5c50: 0x0002, 0x5c51: 0x0002, 0x5c52: 0x0002, 0x5c53: 0x0002, 0x5c54: 0x0002, 0x5c55: 0x0002, 0x5c56: 0x0002, 0x5c57: 0x0002, 0x5c58: 0x0002, 0x5c59: 0x0002, 0x5c5a: 0x0002, 0x5c5b: 0x0002, 0x5c5c: 0x0002, 0x5c5d: 0x0002, 0x5c5e: 0x0002, 0x5c5f: 0x0002, 0x5c60: 0x0002, // Block 0x172, offset 0x5c80 0x5c80: 0x0002, 0x5c81: 0x0002, 0x5c82: 0x0002, 0x5c83: 0x0002, 0x5c84: 0x0002, 0x5c85: 0x0002, 0x5c86: 0x0002, 0x5c87: 0x0002, 0x5c88: 0x0002, 0x5c89: 0x0002, 0x5c8a: 0x0002, 0x5c8b: 0x0002, 0x5c8c: 0x0002, 0x5c8d: 0x0002, 0x5c8e: 0x0002, 0x5c8f: 0x0002, 0x5c90: 0x0002, 0x5c91: 0x0002, 0x5c92: 0x0002, 0x5c93: 0x0002, 0x5c94: 0x0002, 0x5c95: 0x0002, 0x5c96: 0x0002, 0x5c97: 0x0002, 0x5c98: 0x0002, 0x5c99: 0x0002, 0x5c9a: 0x0002, 0x5c9b: 0x0002, 0x5c9c: 0x0002, 0x5c9d: 0x0002, // Block 0x173, offset 0x5cc0 0x5cc0: 0x0002, 0x5cc1: 0x0002, 0x5cc2: 0x0002, 0x5cc3: 0x0002, 0x5cc4: 0x0002, 0x5cc5: 0x0002, 0x5cc6: 0x0002, 0x5cc7: 0x0002, 0x5cc8: 0x0002, 0x5cc9: 0x0002, 0x5cca: 0x0002, 0x5cd0: 0x0002, 0x5cd1: 0x0002, 0x5cd2: 0x0002, 0x5cd3: 0x0002, 0x5cd4: 0x0002, 0x5cd5: 0x0002, 0x5cd6: 0x0002, 0x5cd7: 0x0002, 0x5cd8: 0x0002, 0x5cd9: 0x0002, 0x5cda: 0x0002, 0x5cdb: 0x0002, 0x5cdc: 0x0002, 0x5cdd: 0x0002, 0x5cde: 0x0002, 0x5cdf: 0x0002, 0x5ce0: 0x0002, 0x5ce1: 0x0002, 0x5ce2: 0x0002, 0x5ce3: 0x0002, 0x5ce4: 0x0002, 0x5ce5: 0x0002, 0x5ce6: 0x0002, 0x5ce7: 0x0002, 0x5ce8: 0x0002, 0x5ce9: 0x0002, 0x5cea: 0x0002, 0x5ceb: 0x0002, 0x5cec: 0x0002, 0x5ced: 0x0002, 0x5cee: 0x0002, 0x5cef: 0x0002, 0x5cf0: 0x0002, 0x5cf1: 0x0002, 0x5cf2: 0x0002, 0x5cf3: 0x0002, 0x5cf4: 0x0002, 0x5cf5: 0x0002, 0x5cf6: 0x0002, 0x5cf7: 0x0002, 0x5cf8: 0x0002, 0x5cf9: 0x0002, 0x5cfa: 0x0002, 0x5cfb: 0x0002, 0x5cfc: 0x0002, 0x5cfd: 0x0002, 0x5cfe: 0x0002, 0x5cff: 0x0002, // Block 0x174, offset 0x5d00 0x5d00: 0x0002, 0x5d01: 0x0002, 0x5d02: 0x0002, 0x5d03: 0x0002, 0x5d04: 0x0002, 0x5d05: 0x0002, 0x5d06: 0x0002, 0x5d07: 0x0002, 0x5d08: 0x0002, 0x5d09: 0x0002, 0x5d0a: 0x0002, 0x5d0b: 0x0002, 0x5d0c: 0x0002, 0x5d0d: 0x0002, 0x5d0e: 0x0002, 0x5d0f: 0x0002, 0x5d10: 0x0002, 0x5d11: 0x0002, 0x5d12: 0x0002, 0x5d13: 0x0002, 0x5d14: 0x0002, 0x5d15: 0x0002, 0x5d16: 0x0002, 0x5d17: 0x0002, 0x5d18: 0x0002, 0x5d19: 0x0002, 0x5d1a: 0x0002, 0x5d1b: 0x0002, 0x5d1c: 0x0002, 0x5d1d: 0x0002, 0x5d1e: 0x0002, 0x5d1f: 0x0002, 0x5d20: 0x0002, 0x5d21: 0x0002, 0x5d22: 0x0002, 0x5d23: 0x0002, 0x5d24: 0x0002, 0x5d25: 0x0002, 0x5d26: 0x0002, 0x5d27: 0x0002, 0x5d28: 0x0002, 0x5d29: 0x0002, 0x5d2a: 0x0002, 0x5d2b: 0x0002, 0x5d2c: 0x0002, 0x5d2d: 0x0002, 0x5d2e: 0x0002, 0x5d2f: 0x0002, // Block 0x175, offset 0x5d40 0x5d41: 0x0080, 0x5d60: 0x0010, 0x5d61: 0x0010, 0x5d62: 0x0010, 0x5d63: 0x0010, 0x5d64: 0x0010, 0x5d65: 0x0010, 0x5d66: 0x0010, 0x5d67: 0x0010, 0x5d68: 0x0010, 0x5d69: 0x0010, 0x5d6a: 0x0010, 0x5d6b: 0x0010, 0x5d6c: 0x0010, 0x5d6d: 0x0010, 0x5d6e: 0x0010, 0x5d6f: 0x0010, 0x5d70: 0x0010, 0x5d71: 0x0010, 0x5d72: 0x0010, 0x5d73: 0x0010, 0x5d74: 0x0010, 0x5d75: 0x0010, 0x5d76: 0x0010, 0x5d77: 0x0010, 0x5d78: 0x0010, 0x5d79: 0x0010, 0x5d7a: 0x0010, 0x5d7b: 0x0010, 0x5d7c: 0x0010, 0x5d7d: 0x0010, 0x5d7e: 0x0010, 0x5d7f: 0x0010, // Block 0x176, offset 0x5d80 0x5d80: 0x0010, 0x5d81: 0x0010, 0x5d82: 0x0010, 0x5d83: 0x0010, 0x5d84: 0x0010, 0x5d85: 0x0010, 0x5d86: 0x0010, 0x5d87: 0x0010, 0x5d88: 0x0010, 0x5d89: 0x0010, 0x5d8a: 0x0010, 0x5d8b: 0x0010, 0x5d8c: 0x0010, 0x5d8d: 0x0010, 0x5d8e: 0x0010, 0x5d8f: 0x0010, 0x5d90: 0x0010, 0x5d91: 0x0010, 0x5d92: 0x0010, 0x5d93: 0x0010, 0x5d94: 0x0010, 0x5d95: 0x0010, 0x5d96: 0x0010, 0x5d97: 0x0010, 0x5d98: 0x0010, 0x5d99: 0x0010, 0x5d9a: 0x0010, 0x5d9b: 0x0010, 0x5d9c: 0x0010, 0x5d9d: 0x0010, 0x5d9e: 0x0010, 0x5d9f: 0x0010, 0x5da0: 0x0010, 0x5da1: 0x0010, 0x5da2: 0x0010, 0x5da3: 0x0010, 0x5da4: 0x0010, 0x5da5: 0x0010, 0x5da6: 0x0010, 0x5da7: 0x0010, 0x5da8: 0x0010, 0x5da9: 0x0010, 0x5daa: 0x0010, 0x5dab: 0x0010, 0x5dac: 0x0010, 0x5dad: 0x0010, 0x5dae: 0x0010, 0x5daf: 0x0010, } // wordsIndex: 36 blocks, 2304 entries, 4608 bytes // Block 0 is the zero block. var wordsIndex = [2304]property{ // Block 0x0, offset 0x0 // Block 0x1, offset 0x40 // Block 0x2, offset 0x80 // Block 0x3, offset 0xc0 0xc2: 0x01, 0xc3: 0x02, 0xc4: 0x03, 0xc5: 0x03, 0xc6: 0x03, 0xc7: 0x03, 0xc8: 0x03, 0xc9: 0x03, 0xca: 0x03, 0xcb: 0x04, 0xcc: 0x05, 0xcd: 0x06, 0xce: 0x07, 0xcf: 0x08, 0xd0: 0x03, 0xd1: 0x03, 0xd2: 0x09, 0xd3: 0x03, 0xd4: 0x0a, 0xd5: 0x0b, 0xd6: 0x0c, 0xd7: 0x0d, 0xd8: 0x0e, 0xd9: 0x0f, 0xda: 0x03, 0xdb: 0x10, 0xdc: 0x11, 0xdd: 0x12, 0xde: 0x13, 0xdf: 0x14, 0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xe4: 0x06, 0xe5: 0x07, 0xe6: 0x07, 0xe7: 0x07, 0xe8: 0x07, 0xe9: 0x07, 0xea: 0x08, 0xeb: 0x09, 0xec: 0x09, 0xed: 0x0a, 0xef: 0x0b, 0xf0: 0x1f, 0xf3: 0x21, // Block 0x4, offset 0x100 0x120: 0x15, 0x121: 0x16, 0x122: 0x17, 0x123: 0x18, 0x124: 0x19, 0x125: 0x1a, 0x126: 0x1b, 0x127: 0x1c, 0x128: 0x1d, 0x129: 0x1e, 0x12a: 0x1f, 0x12b: 0x20, 0x12c: 0x21, 0x12d: 0x22, 0x12e: 0x23, 0x12f: 0x24, 0x130: 0x25, 0x131: 0x26, 0x132: 0x27, 0x133: 0x28, 0x134: 0x29, 0x135: 0x2a, 0x136: 0x2b, 0x137: 0x2c, 0x138: 0x2d, 0x139: 0x2e, 0x13a: 0x2f, 0x13b: 0x30, 0x13c: 0x31, 0x13d: 0x32, 0x13e: 0x33, 0x13f: 0x34, // Block 0x5, offset 0x140 0x140: 0x35, 0x141: 0x36, 0x142: 0x37, 0x143: 0x38, 0x144: 0x03, 0x145: 0x03, 0x146: 0x03, 0x147: 0x03, 0x148: 0x03, 0x149: 0x39, 0x14a: 0x3a, 0x14b: 0x3b, 0x14c: 0x3c, 0x14d: 0x3d, 0x14e: 0x3e, 0x14f: 0x3f, 0x150: 0x40, 0x151: 0x03, 0x152: 0x03, 0x153: 0x03, 0x154: 0x03, 0x155: 0x03, 0x156: 0x03, 0x157: 0x03, 0x158: 0x03, 0x159: 0x41, 0x15a: 0x42, 0x15b: 0x43, 0x15c: 0x44, 0x15d: 0x45, 0x15e: 0x46, 0x15f: 0x47, 0x160: 0x48, 0x161: 0x49, 0x162: 0x4a, 0x163: 0x4b, 0x164: 0x4c, 0x165: 0x4d, 0x167: 0x4e, 0x168: 0x4f, 0x169: 0x50, 0x16a: 0x51, 0x16b: 0x52, 0x16c: 0x53, 0x16d: 0x54, 0x16e: 0x55, 0x16f: 0x56, 0x170: 0x57, 0x171: 0x58, 0x172: 0x59, 0x173: 0x5a, 0x174: 0x03, 0x175: 0x03, 0x176: 0x03, 0x177: 0x05, 0x178: 0x03, 0x179: 0x03, 0x17a: 0x03, 0x17b: 0x03, 0x17c: 0x5b, 0x17d: 0x5c, 0x17e: 0x5d, 0x17f: 0x5e, // Block 0x6, offset 0x180 0x180: 0x5f, 0x181: 0x60, 0x182: 0x61, 0x183: 0x62, 0x184: 0x63, 0x185: 0x64, 0x186: 0x65, 0x18c: 0x66, 0x18f: 0x67, 0x192: 0x68, 0x193: 0x69, 0x196: 0x6a, 0x197: 0x6b, 0x198: 0x6c, 0x199: 0x6d, 0x19a: 0x6e, 0x19b: 0x6f, 0x19c: 0x70, 0x19d: 0x71, 0x19e: 0x72, 0x1a4: 0x73, 0x1ac: 0x74, 0x1ad: 0x75, 0x1b0: 0x03, 0x1b1: 0x03, 0x1b2: 0x03, 0x1b3: 0x76, 0x1b4: 0x77, 0x1b5: 0x78, 0x1b6: 0x79, 0x1b7: 0x7a, 0x1b8: 0x7b, 0x1ba: 0x7c, 0x1bb: 0x7d, 0x1bc: 0x7e, 0x1bd: 0x7e, 0x1be: 0x7e, 0x1bf: 0x7f, // Block 0x7, offset 0x1c0 0x1c0: 0x80, 0x1c1: 0x81, 0x1c2: 0x82, 0x1c3: 0x83, 0x1c4: 0x84, 0x1c5: 0x03, 0x1c6: 0x85, 0x1c7: 0x86, 0x1ca: 0x87, 0x1cb: 0x88, 0x1cc: 0x89, 0x1cd: 0x8a, 0x1d0: 0x7e, 0x1d1: 0x7e, 0x1d2: 0x7e, 0x1d3: 0x7e, 0x1d4: 0x7e, 0x1d5: 0x7e, 0x1d6: 0x7e, 0x1d7: 0x7e, 0x1d8: 0x7e, 0x1d9: 0x7e, 0x1da: 0x7e, 0x1db: 0x7e, 0x1dc: 0x7e, 0x1dd: 0x7e, 0x1de: 0x7e, 0x1df: 0x7e, 0x1e0: 0x7e, 0x1e1: 0x7e, 0x1e2: 0x7e, 0x1e3: 0x7e, 0x1e4: 0x7e, 0x1e5: 0x7e, 0x1e6: 0x7e, 0x1e7: 0x7e, 0x1e8: 0x7e, 0x1e9: 0x7e, 0x1ea: 0x7e, 0x1eb: 0x7e, 0x1ec: 0x7e, 0x1ed: 0x7e, 0x1ee: 0x7e, 0x1ef: 0x7e, 0x1f0: 0x7e, 0x1f1: 0x7e, 0x1f2: 0x7e, 0x1f3: 0x7e, 0x1f4: 0x7e, 0x1f5: 0x7e, 0x1f6: 0x7e, 0x1f7: 0x7e, 0x1f8: 0x7e, 0x1f9: 0x7e, 0x1fa: 0x7e, 0x1fb: 0x7e, 0x1fc: 0x7e, 0x1fd: 0x7e, 0x1fe: 0x7e, 0x1ff: 0x7e, // Block 0x8, offset 0x200 0x200: 0x7e, 0x201: 0x7e, 0x202: 0x7e, 0x203: 0x7e, 0x204: 0x7e, 0x205: 0x7e, 0x206: 0x7e, 0x207: 0x7e, 0x208: 0x7e, 0x209: 0x7e, 0x20a: 0x7e, 0x20b: 0x7e, 0x20c: 0x7e, 0x20d: 0x7e, 0x20e: 0x7e, 0x20f: 0x7e, 0x210: 0x7e, 0x211: 0x7e, 0x212: 0x7e, 0x213: 0x7e, 0x214: 0x7e, 0x215: 0x7e, 0x216: 0x7e, 0x217: 0x7e, 0x218: 0x7e, 0x219: 0x7e, 0x21a: 0x7e, 0x21b: 0x7e, 0x21c: 0x7e, 0x21d: 0x7e, 0x21e: 0x7e, 0x21f: 0x7e, 0x220: 0x7e, 0x221: 0x7e, 0x222: 0x7e, 0x223: 0x7e, 0x224: 0x7e, 0x225: 0x7e, 0x226: 0x7e, 0x227: 0x7e, 0x228: 0x7e, 0x229: 0x7e, 0x22a: 0x7e, 0x22b: 0x7e, 0x22c: 0x7e, 0x22d: 0x7e, 0x22e: 0x7e, 0x22f: 0x7e, 0x230: 0x7e, 0x231: 0x7e, 0x232: 0x7e, 0x233: 0x7e, 0x234: 0x7e, 0x235: 0x7e, 0x236: 0x7e, 0x238: 0x7e, 0x239: 0x7e, 0x23a: 0x7e, 0x23b: 0x7e, 0x23c: 0x7e, 0x23d: 0x7e, 0x23e: 0x7e, 0x23f: 0x7e, // Block 0x9, offset 0x240 0x240: 0x7e, 0x241: 0x7e, 0x242: 0x7e, 0x243: 0x7e, 0x244: 0x7e, 0x245: 0x7e, 0x246: 0x7e, 0x247: 0x7e, 0x248: 0x7e, 0x249: 0x7e, 0x24a: 0x7e, 0x24b: 0x7e, 0x24c: 0x7e, 0x24d: 0x7e, 0x24e: 0x7e, 0x24f: 0x7e, 0x250: 0x7e, 0x251: 0x7e, 0x252: 0x7e, 0x253: 0x7e, 0x254: 0x7e, 0x255: 0x7e, 0x256: 0x7e, 0x257: 0x7e, 0x258: 0x7e, 0x259: 0x7e, 0x25a: 0x7e, 0x25b: 0x7e, 0x25c: 0x7e, 0x25d: 0x7e, 0x25e: 0x7e, 0x25f: 0x7e, 0x260: 0x7e, 0x261: 0x7e, 0x262: 0x7e, 0x263: 0x7e, 0x264: 0x7e, 0x265: 0x7e, 0x266: 0x7e, 0x267: 0x7e, 0x268: 0x7e, 0x269: 0x7e, 0x26a: 0x7e, 0x26b: 0x7e, 0x26c: 0x7e, 0x26d: 0x7e, 0x26e: 0x7e, 0x26f: 0x7e, 0x270: 0x7e, 0x271: 0x7e, 0x272: 0x7e, 0x273: 0x7e, 0x274: 0x7e, 0x275: 0x7e, 0x276: 0x7e, 0x277: 0x7e, 0x278: 0x7e, 0x279: 0x7e, 0x27a: 0x7e, 0x27b: 0x7e, 0x27c: 0x7e, 0x27d: 0x7e, 0x27e: 0x7e, 0x27f: 0x7e, // Block 0xa, offset 0x280 0x280: 0x03, 0x281: 0x03, 0x282: 0x03, 0x283: 0x03, 0x284: 0x03, 0x285: 0x03, 0x286: 0x03, 0x287: 0x03, 0x288: 0x03, 0x289: 0x03, 0x28a: 0x03, 0x28b: 0x03, 0x28c: 0x03, 0x28d: 0x03, 0x28e: 0x03, 0x28f: 0x03, 0x290: 0x03, 0x291: 0x03, 0x292: 0x8b, 0x293: 0x8c, 0x294: 0x03, 0x295: 0x03, 0x296: 0x03, 0x297: 0x03, 0x298: 0x8d, 0x299: 0x8e, 0x29a: 0x8f, 0x29b: 0x90, 0x29c: 0x91, 0x29d: 0x03, 0x29e: 0x03, 0x29f: 0x92, 0x2a0: 0x93, 0x2a1: 0x94, 0x2a2: 0x95, 0x2a3: 0x96, 0x2a4: 0x97, 0x2a5: 0x98, 0x2a6: 0x99, 0x2a7: 0x9a, 0x2a8: 0x9b, 0x2a9: 0x9c, 0x2aa: 0x9d, 0x2ab: 0x9e, 0x2ac: 0x9f, 0x2ad: 0xa0, 0x2ae: 0x03, 0x2af: 0xa1, 0x2b0: 0x03, 0x2b1: 0x03, 0x2b2: 0x03, 0x2b3: 0x03, 0x2b4: 0x03, 0x2b5: 0x03, 0x2b6: 0x03, 0x2b7: 0x03, 0x2b8: 0x03, 0x2b9: 0x03, 0x2ba: 0x03, 0x2bb: 0x03, 0x2bc: 0x03, 0x2bd: 0x03, 0x2be: 0x03, 0x2bf: 0x03, // Block 0xb, offset 0x2c0 0x2c0: 0x03, 0x2c1: 0x03, 0x2c2: 0x03, 0x2c3: 0x03, 0x2c4: 0x03, 0x2c5: 0x03, 0x2c6: 0x03, 0x2c7: 0x03, 0x2c8: 0x03, 0x2c9: 0x03, 0x2ca: 0x03, 0x2cb: 0x03, 0x2cc: 0x03, 0x2cd: 0x03, 0x2ce: 0x03, 0x2cf: 0x03, 0x2d0: 0x03, 0x2d1: 0x03, 0x2d2: 0x03, 0x2d3: 0x03, 0x2d4: 0x03, 0x2d5: 0x03, 0x2d6: 0x03, 0x2d7: 0x03, 0x2d8: 0x03, 0x2d9: 0x03, 0x2da: 0x03, 0x2db: 0x03, 0x2dc: 0x03, 0x2dd: 0x03, 0x2de: 0x03, 0x2df: 0x03, 0x2e0: 0x03, 0x2e1: 0x03, 0x2e2: 0x03, 0x2e3: 0x03, 0x2e4: 0x03, 0x2e5: 0x03, 0x2e6: 0x03, 0x2e7: 0x03, 0x2e8: 0x03, 0x2e9: 0x03, 0x2ea: 0x03, 0x2eb: 0x03, 0x2ec: 0x03, 0x2ed: 0x03, 0x2ee: 0x03, 0x2ef: 0x03, 0x2f0: 0x03, 0x2f1: 0x03, 0x2f2: 0x03, 0x2f3: 0x03, 0x2f4: 0x03, 0x2f5: 0x03, 0x2f6: 0x03, 0x2f7: 0x03, 0x2f8: 0x03, 0x2f9: 0x03, 0x2fa: 0x03, 0x2fb: 0x03, 0x2fc: 0x03, 0x2fd: 0x03, 0x2fe: 0x03, 0x2ff: 0x03, // Block 0xc, offset 0x300 0x300: 0x03, 0x301: 0x03, 0x302: 0x03, 0x303: 0x03, 0x304: 0x03, 0x305: 0x03, 0x306: 0x03, 0x307: 0x03, 0x308: 0x03, 0x309: 0x03, 0x30a: 0x03, 0x30b: 0x03, 0x30c: 0x03, 0x30d: 0x03, 0x30e: 0x03, 0x30f: 0x03, 0x310: 0x03, 0x311: 0x03, 0x312: 0x03, 0x313: 0x03, 0x314: 0x03, 0x315: 0x03, 0x316: 0x03, 0x317: 0x03, 0x318: 0x03, 0x319: 0x03, 0x31a: 0x03, 0x31b: 0x03, 0x31c: 0x03, 0x31d: 0x03, 0x31e: 0xa2, 0x31f: 0xa3, // Block 0xd, offset 0x340 0x364: 0x7e, 0x365: 0x7e, 0x366: 0x7e, 0x367: 0x7e, 0x368: 0x7e, 0x369: 0xa4, 0x36a: 0x7e, 0x36b: 0xa5, 0x36c: 0xa6, 0x36d: 0xa7, 0x36e: 0xa8, 0x36f: 0xa9, 0x370: 0x03, 0x371: 0x03, 0x372: 0x03, 0x373: 0x03, 0x374: 0xaa, 0x375: 0xab, 0x376: 0xac, 0x377: 0xad, 0x378: 0xae, 0x379: 0xaf, 0x37a: 0x03, 0x37b: 0xb0, 0x37c: 0xb1, 0x37d: 0xb2, 0x37e: 0xb3, 0x37f: 0xb4, // Block 0xe, offset 0x380 0x380: 0xb5, 0x381: 0xb6, 0x382: 0x03, 0x383: 0xb7, 0x385: 0xb8, 0x387: 0xb9, 0x38a: 0xba, 0x38b: 0xbb, 0x38c: 0xbc, 0x38d: 0xbd, 0x38e: 0xbe, 0x38f: 0xbf, 0x390: 0x03, 0x391: 0x03, 0x392: 0xc0, 0x393: 0xc1, 0x394: 0xc2, 0x395: 0xc3, 0x396: 0xc4, 0x397: 0x94, 0x398: 0x03, 0x399: 0x03, 0x39a: 0x03, 0x39b: 0x03, 0x39c: 0xc5, 0x39d: 0xc6, 0x39e: 0xc7, 0x3a0: 0xc8, 0x3a1: 0xc9, 0x3a2: 0xca, 0x3a3: 0xcb, 0x3a4: 0xcc, 0x3a5: 0xcd, 0x3a6: 0xce, 0x3a8: 0xcf, 0x3a9: 0xd0, 0x3aa: 0xd1, 0x3ab: 0xd2, 0x3ac: 0x4b, 0x3ad: 0xd3, 0x3ae: 0xd4, 0x3b0: 0x03, 0x3b1: 0xd5, 0x3b2: 0xd6, 0x3b3: 0xd6, 0x3b4: 0xd7, 0x3b5: 0xd8, 0x3b6: 0xd9, 0x3ba: 0xda, 0x3bb: 0xdb, 0x3bc: 0xdc, 0x3bd: 0xdd, 0x3be: 0xde, 0x3bf: 0xdf, // Block 0xf, offset 0x3c0 0x3c0: 0xe0, 0x3c1: 0xe1, 0x3c2: 0xe2, 0x3c3: 0xe3, 0x3c4: 0xe4, 0x3c5: 0xe5, 0x3c6: 0xe6, 0x3c7: 0xe7, 0x3c8: 0xe8, 0x3c9: 0xe9, 0x3ca: 0xea, 0x3cb: 0xeb, 0x3cc: 0xec, 0x3cd: 0xed, 0x3ce: 0xee, 0x3cf: 0xef, 0x3d0: 0xf0, 0x3d1: 0xf1, 0x3d2: 0xf2, 0x3d3: 0xf3, 0x3d6: 0xf4, 0x3d7: 0xf5, 0x3d8: 0xf2, 0x3d9: 0xf6, 0x3da: 0xf7, 0x3db: 0xf8, 0x3dc: 0xf9, 0x3e0: 0xfa, 0x3e2: 0xfb, 0x3e3: 0xfc, 0x3e4: 0xfd, 0x3e5: 0xfe, 0x3e6: 0xff, 0x3e7: 0x100, 0x3e8: 0x101, 0x3e9: 0x102, 0x3ea: 0x103, 0x3eb: 0x49, 0x3ed: 0x104, 0x3ef: 0x105, 0x3f0: 0x106, 0x3f1: 0x107, 0x3f2: 0x108, 0x3f4: 0x109, 0x3f5: 0x10a, 0x3f6: 0x10b, 0x3f7: 0x10c, 0x3fb: 0x10d, 0x3fc: 0x10e, 0x3fd: 0x10f, 0x3fe: 0x110, // Block 0x10, offset 0x400 0x400: 0x03, 0x401: 0x03, 0x402: 0x03, 0x403: 0x03, 0x404: 0x03, 0x405: 0x03, 0x406: 0x03, 0x407: 0x03, 0x408: 0x03, 0x409: 0x03, 0x40a: 0x03, 0x40b: 0x03, 0x40c: 0x03, 0x40d: 0x03, 0x40e: 0xcd, 0x410: 0x03, 0x411: 0x111, 0x412: 0x03, 0x413: 0x03, 0x414: 0x03, 0x415: 0x112, 0x43e: 0xab, 0x43f: 0x113, // Block 0x11, offset 0x440 0x440: 0x03, 0x441: 0x03, 0x442: 0x03, 0x443: 0x03, 0x444: 0x03, 0x445: 0x03, 0x446: 0x03, 0x447: 0x03, 0x448: 0x03, 0x449: 0x03, 0x44a: 0x03, 0x44b: 0x03, 0x44c: 0x03, 0x44d: 0x03, 0x44e: 0x03, 0x44f: 0x03, 0x450: 0x114, 0x451: 0x115, 0x452: 0x03, 0x453: 0x03, 0x454: 0x03, 0x455: 0x03, 0x456: 0x03, 0x457: 0x03, 0x458: 0x03, 0x459: 0x03, 0x45a: 0x03, 0x45b: 0x03, 0x45c: 0x03, 0x45d: 0x03, 0x45e: 0x03, 0x45f: 0x03, 0x460: 0x03, 0x461: 0x03, 0x462: 0x03, 0x463: 0x03, 0x464: 0x03, 0x465: 0x03, 0x466: 0x03, 0x467: 0x03, 0x468: 0x03, 0x469: 0x03, 0x46a: 0x03, 0x46b: 0x03, 0x46c: 0x03, 0x46d: 0x03, 0x46e: 0x03, 0x46f: 0x03, 0x470: 0x03, 0x471: 0x03, 0x472: 0x03, 0x473: 0x03, 0x474: 0x03, 0x475: 0x03, 0x476: 0x03, 0x477: 0x03, 0x478: 0x03, 0x479: 0x03, 0x47a: 0x03, 0x47b: 0x03, 0x47c: 0x03, 0x47d: 0x03, 0x47e: 0x03, 0x47f: 0x03, // Block 0x12, offset 0x480 0x480: 0x03, 0x481: 0x03, 0x482: 0x03, 0x483: 0x03, 0x484: 0x03, 0x485: 0x03, 0x486: 0x03, 0x487: 0x03, 0x488: 0x03, 0x489: 0x03, 0x48a: 0x03, 0x48b: 0x03, 0x48c: 0x03, 0x48d: 0x03, 0x48e: 0x03, 0x48f: 0xb7, 0x490: 0x03, 0x491: 0x03, 0x492: 0x03, 0x493: 0x03, 0x494: 0x03, 0x495: 0x03, 0x496: 0x03, 0x497: 0x03, 0x498: 0x03, 0x499: 0x116, // Block 0x13, offset 0x4c0 0x4c4: 0x117, 0x4e0: 0x03, 0x4e1: 0x03, 0x4e2: 0x03, 0x4e3: 0x03, 0x4e4: 0x03, 0x4e5: 0x03, 0x4e6: 0x03, 0x4e7: 0x03, 0x4e8: 0x49, 0x4e9: 0x118, 0x4ea: 0x119, 0x4eb: 0x11a, 0x4ec: 0x11b, 0x4ed: 0x11c, 0x4ee: 0x11d, 0x4f5: 0x11e, 0x4f9: 0x03, 0x4fa: 0x11f, 0x4fb: 0x120, 0x4fc: 0x03, 0x4fd: 0x121, 0x4fe: 0x122, 0x4ff: 0x123, // Block 0x14, offset 0x500 0x53f: 0x124, // Block 0x15, offset 0x540 0x540: 0x125, 0x541: 0x7e, 0x542: 0x7e, 0x543: 0x7e, 0x544: 0x126, 0x545: 0x127, 0x570: 0x03, 0x571: 0x128, 0x572: 0x129, // Block 0x16, offset 0x580 0x5b3: 0x12a, 0x5bc: 0x12b, 0x5bd: 0x12c, // Block 0x17, offset 0x5c0 0x5c5: 0x12d, 0x5c6: 0x12e, 0x5c9: 0x12f, 0x5d0: 0x03, 0x5d1: 0x130, 0x5d2: 0x131, 0x5d3: 0x132, 0x5d4: 0x133, 0x5d5: 0x134, 0x5d6: 0x03, 0x5d7: 0x03, 0x5d8: 0x03, 0x5d9: 0x03, 0x5da: 0x135, 0x5db: 0x136, 0x5dc: 0x137, 0x5dd: 0x138, 0x5de: 0x139, 0x5df: 0x13a, 0x5e8: 0x13b, 0x5e9: 0x13c, 0x5ea: 0x13d, 0x5fc: 0x13e, // Block 0x18, offset 0x600 0x600: 0x13f, 0x601: 0x140, 0x602: 0x141, 0x604: 0x142, 0x605: 0x143, 0x60a: 0x144, 0x60b: 0x145, 0x613: 0x146, 0x617: 0x147, 0x61b: 0x148, 0x61f: 0x149, 0x620: 0x03, 0x621: 0x03, 0x622: 0x03, 0x623: 0x14a, 0x624: 0x03, 0x625: 0x14b, 0x638: 0x14c, 0x639: 0x14d, 0x63a: 0x14e, // Block 0x19, offset 0x640 0x640: 0x14f, 0x642: 0x150, 0x643: 0x151, 0x644: 0x152, 0x645: 0x153, 0x646: 0x154, 0x647: 0x155, 0x648: 0x156, 0x649: 0x157, 0x64a: 0x158, 0x64b: 0x158, 0x64c: 0x159, 0x64d: 0x158, 0x64e: 0x15a, 0x64f: 0x15b, 0x650: 0x158, 0x651: 0x158, 0x652: 0x158, 0x653: 0x15c, 0x654: 0x15d, 0x655: 0x15e, 0x656: 0x15f, 0x657: 0x160, 0x658: 0x158, 0x659: 0x161, 0x65a: 0x158, 0x65b: 0x162, 0x65f: 0x163, 0x660: 0x164, 0x661: 0x165, 0x662: 0x166, 0x663: 0x167, 0x664: 0x168, 0x665: 0x169, 0x666: 0x158, 0x667: 0x158, 0x669: 0x16a, 0x66a: 0x158, 0x66b: 0x158, 0x66f: 0x12a, 0x670: 0x158, 0x671: 0x158, 0x672: 0x158, 0x673: 0x158, 0x674: 0x158, 0x675: 0x158, 0x676: 0x158, 0x677: 0x158, 0x678: 0x158, 0x679: 0x158, 0x67a: 0x158, 0x67b: 0x158, 0x67c: 0x158, 0x67d: 0x158, 0x67e: 0x158, 0x67f: 0x15d, // Block 0x1a, offset 0x680 0x680: 0x7e, 0x681: 0x7e, 0x682: 0x7e, 0x683: 0x7e, 0x684: 0x7e, 0x685: 0x7e, 0x686: 0x7e, 0x687: 0x7e, 0x688: 0x7e, 0x689: 0x7e, 0x68a: 0x7e, 0x68b: 0x7e, 0x68c: 0x7e, 0x68d: 0x7e, 0x68e: 0x7e, 0x68f: 0x7e, 0x690: 0x7e, 0x691: 0x7e, 0x692: 0x7e, 0x693: 0x7e, 0x694: 0x7e, 0x695: 0x7e, 0x696: 0x7e, 0x697: 0x7e, 0x698: 0x7e, 0x699: 0x7e, 0x69a: 0x7e, 0x69b: 0x16b, 0x69c: 0x7e, 0x69d: 0x7e, 0x69e: 0x7e, 0x69f: 0x7e, 0x6a0: 0x7e, 0x6a1: 0x7e, 0x6a2: 0x7e, 0x6a3: 0x7e, 0x6a4: 0x7e, 0x6a5: 0x7e, 0x6a6: 0x7e, 0x6a7: 0x7e, 0x6a8: 0x7e, 0x6a9: 0x7e, 0x6aa: 0x7e, 0x6ab: 0x7e, 0x6ac: 0x7e, 0x6ad: 0x7e, 0x6ae: 0x7e, 0x6af: 0x7e, 0x6b0: 0x7e, 0x6b1: 0x7e, 0x6b2: 0x7e, 0x6b3: 0x7e, 0x6b4: 0x7e, 0x6b5: 0x7e, 0x6b6: 0x7e, 0x6b7: 0x7e, 0x6b8: 0x7e, 0x6b9: 0x7e, 0x6ba: 0x7e, 0x6bb: 0x7e, 0x6bc: 0x7e, 0x6bd: 0x7e, 0x6be: 0x7e, 0x6bf: 0x7e, // Block 0x1b, offset 0x6c0 0x6c0: 0x7e, 0x6c1: 0x7e, 0x6c2: 0x7e, 0x6c3: 0x7e, 0x6c4: 0x7e, 0x6c5: 0x7e, 0x6c6: 0x7e, 0x6c7: 0x7e, 0x6c8: 0x7e, 0x6c9: 0x7e, 0x6ca: 0x7e, 0x6cb: 0x7e, 0x6cc: 0x7e, 0x6cd: 0x7e, 0x6ce: 0x7e, 0x6cf: 0x7e, 0x6d0: 0x7e, 0x6d1: 0x7e, 0x6d2: 0x7e, 0x6d3: 0x7e, 0x6d4: 0x7e, 0x6d5: 0x7e, 0x6d6: 0x7e, 0x6d7: 0x7e, 0x6d8: 0x7e, 0x6d9: 0x7e, 0x6da: 0x7e, 0x6db: 0x7e, 0x6dc: 0x16c, 0x6dd: 0x7e, 0x6de: 0x7e, 0x6df: 0x7e, 0x6e0: 0x16d, 0x6e1: 0x7e, 0x6e2: 0x7e, 0x6e3: 0x7e, 0x6e4: 0x7e, 0x6e5: 0x7e, 0x6e6: 0x7e, 0x6e7: 0x7e, 0x6e8: 0x7e, 0x6e9: 0x7e, 0x6ea: 0x7e, 0x6eb: 0x7e, 0x6ec: 0x7e, 0x6ed: 0x7e, 0x6ee: 0x7e, 0x6ef: 0x7e, 0x6f0: 0x7e, 0x6f1: 0x7e, 0x6f2: 0x7e, 0x6f3: 0x7e, 0x6f4: 0x7e, 0x6f5: 0x7e, 0x6f6: 0x7e, 0x6f7: 0x7e, 0x6f8: 0x7e, 0x6f9: 0x7e, 0x6fa: 0x7e, 0x6fb: 0x7e, 0x6fc: 0x7e, 0x6fd: 0x7e, 0x6fe: 0x7e, 0x6ff: 0x7e, // Block 0x1c, offset 0x700 0x700: 0x7e, 0x701: 0x7e, 0x702: 0x7e, 0x703: 0x7e, 0x704: 0x7e, 0x705: 0x7e, 0x706: 0x7e, 0x707: 0x7e, 0x708: 0x7e, 0x709: 0x7e, 0x70a: 0x7e, 0x70b: 0x7e, 0x70c: 0x7e, 0x70d: 0x7e, 0x70e: 0x7e, 0x70f: 0x7e, 0x710: 0x7e, 0x711: 0x7e, 0x712: 0x7e, 0x713: 0x7e, 0x714: 0x7e, 0x715: 0x7e, 0x716: 0x7e, 0x717: 0x7e, 0x718: 0x7e, 0x719: 0x7e, 0x71a: 0x7e, 0x71b: 0x7e, 0x71c: 0x7e, 0x71d: 0x7e, 0x71e: 0x7e, 0x71f: 0x7e, 0x720: 0x7e, 0x721: 0x7e, 0x722: 0x7e, 0x723: 0x7e, 0x724: 0x7e, 0x725: 0x7e, 0x726: 0x7e, 0x727: 0x7e, 0x728: 0x7e, 0x729: 0x7e, 0x72a: 0x7e, 0x72b: 0x7e, 0x72c: 0x7e, 0x72d: 0x7e, 0x72e: 0x7e, 0x72f: 0x7e, 0x730: 0x7e, 0x731: 0x7e, 0x732: 0x7e, 0x733: 0x7e, 0x734: 0x7e, 0x735: 0x7e, 0x736: 0x7e, 0x737: 0x7e, 0x738: 0x7e, 0x739: 0x7e, 0x73a: 0x16e, 0x73b: 0x7e, 0x73c: 0x7e, 0x73d: 0x7e, 0x73e: 0x7e, 0x73f: 0x7e, // Block 0x1d, offset 0x740 0x740: 0x7e, 0x741: 0x7e, 0x742: 0x7e, 0x743: 0x7e, 0x744: 0x7e, 0x745: 0x7e, 0x746: 0x7e, 0x747: 0x7e, 0x748: 0x7e, 0x749: 0x7e, 0x74a: 0x7e, 0x74b: 0x7e, 0x74c: 0x7e, 0x74d: 0x7e, 0x74e: 0x7e, 0x74f: 0x7e, 0x750: 0x7e, 0x751: 0x7e, 0x752: 0x7e, 0x753: 0x7e, 0x754: 0x7e, 0x755: 0x7e, 0x756: 0x7e, 0x757: 0x7e, 0x758: 0x7e, 0x759: 0x7e, 0x75a: 0x7e, 0x75b: 0x7e, 0x75c: 0x7e, 0x75d: 0x7e, 0x75e: 0x7e, 0x75f: 0x7e, 0x760: 0x7e, 0x761: 0x7e, 0x762: 0x7e, 0x763: 0x7e, 0x764: 0x7e, 0x765: 0x7e, 0x766: 0x7e, 0x767: 0x7e, 0x768: 0x7e, 0x769: 0x7e, 0x76a: 0x7e, 0x76b: 0x7e, 0x76c: 0x7e, 0x76d: 0x7e, 0x76e: 0x7e, 0x76f: 0x16f, // Block 0x1e, offset 0x780 0x7a0: 0x7e, 0x7a1: 0x7e, 0x7a2: 0x7e, 0x7a3: 0x7e, 0x7a4: 0x7e, 0x7a5: 0x7e, 0x7a6: 0x7e, 0x7a7: 0x7e, 0x7a8: 0x170, // Block 0x1f, offset 0x7c0 0x7c0: 0x7e, 0x7c1: 0x7e, 0x7c2: 0x7e, 0x7c3: 0x7e, 0x7c4: 0x7e, 0x7c5: 0x7e, 0x7c6: 0x7e, 0x7c7: 0x7e, 0x7c8: 0x7e, 0x7c9: 0x7e, 0x7ca: 0x7e, 0x7cb: 0x7e, 0x7cc: 0x7e, 0x7cd: 0x171, 0x7ce: 0x7e, 0x7cf: 0x7e, 0x7d0: 0x7e, 0x7d1: 0x7e, 0x7d2: 0x7e, 0x7d3: 0x7e, 0x7d4: 0x7e, 0x7d5: 0x7e, 0x7d6: 0x7e, 0x7d7: 0x7e, 0x7d8: 0x7e, 0x7d9: 0x7e, 0x7da: 0x7e, 0x7db: 0x7e, 0x7dc: 0x7e, 0x7dd: 0x7e, 0x7de: 0x7e, 0x7df: 0x7e, 0x7e0: 0x7e, 0x7e1: 0x7e, 0x7e2: 0x7e, 0x7e3: 0x7e, 0x7e4: 0x7e, 0x7e5: 0x7e, 0x7e6: 0x7e, 0x7e7: 0x7e, 0x7e8: 0x7e, 0x7e9: 0x7e, 0x7ea: 0x7e, 0x7eb: 0x7e, 0x7ec: 0x7e, 0x7ed: 0x7e, 0x7ee: 0x7e, 0x7ef: 0x7e, 0x7f0: 0x7e, 0x7f1: 0x7e, 0x7f2: 0x7e, 0x7f3: 0x7e, 0x7f4: 0x7e, 0x7f5: 0x7e, 0x7f6: 0x7e, 0x7f7: 0x7e, 0x7f8: 0x7e, 0x7f9: 0x7e, 0x7fa: 0x7e, 0x7fb: 0x7e, 0x7fc: 0x7e, 0x7fd: 0x7e, 0x7fe: 0x7e, 0x7ff: 0x7e, // Block 0x20, offset 0x800 0x800: 0x7e, 0x801: 0x7e, 0x802: 0x7e, 0x803: 0x7e, 0x804: 0x7e, 0x805: 0x7e, 0x806: 0x7e, 0x807: 0x7e, 0x808: 0x7e, 0x809: 0x7e, 0x80a: 0x7e, 0x80b: 0x7e, 0x80c: 0x7e, 0x80d: 0x7e, 0x80e: 0x172, // Block 0x21, offset 0x840 0x850: 0x0c, 0x851: 0x0d, 0x852: 0x0e, 0x853: 0x0f, 0x854: 0x10, 0x856: 0x11, 0x85a: 0x12, 0x85b: 0x13, 0x85c: 0x14, 0x85d: 0x15, 0x85e: 0x16, 0x85f: 0x17, 0x860: 0x07, 0x861: 0x07, 0x862: 0x07, 0x863: 0x07, 0x864: 0x07, 0x865: 0x07, 0x866: 0x07, 0x867: 0x07, 0x868: 0x07, 0x869: 0x07, 0x86a: 0x18, 0x86b: 0x19, 0x86c: 0x1a, 0x86d: 0x07, 0x86e: 0x1b, 0x86f: 0x1c, 0x870: 0x07, 0x871: 0x1d, 0x872: 0x1e, // Block 0x22, offset 0x880 0x880: 0x173, 0x881: 0x05, 0x884: 0x05, 0x885: 0x05, 0x886: 0x05, 0x887: 0x174, // Block 0x23, offset 0x8c0 0x8e0: 0x20, } golang-github-clipperhouse-uax29-2.7.0/words/unicode_test.go000066400000000000000000017415161515045622700241150ustar00rootroot00000000000000package words_test // generated by github.com/clipperhouse/uax29/v2 // from https://www.unicode.org/Public/17.0.0/ucd/auxiliary/WordBreakTest.txt type unicodeTest struct { input []byte expected [][]byte comment string } var unicodeTests = [1944]unicodeTest{ { input: []byte{0xd, 0xd}, expected: [][]byte{{0xd}, {0xd}}, comment: "÷ [0.2] (CR) ÷ [3.1] (CR) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xd, 0xa}, expected: [][]byte{{0xd, 0xa}}, comment: "÷ [0.2] (CR) × [3.0] (LF) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xd, 0xb}, expected: [][]byte{{0xd}, {0xb}}, comment: "÷ [0.2] (CR) ÷ [3.1] (Newline) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x80}, expected: [][]byte{{0xd}, {0xcc, 0x80}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xd, 0xc2, 0xad}, expected: [][]byte{{0xd}, {0xc2, 0xad}}, comment: "÷ [0.2] (CR) ÷ [3.1] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xd, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xd}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] (CR) ÷ [3.1] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xd, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xd}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] (CR) ÷ [3.1] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0x41}, expected: [][]byte{{0xd}, {0x41}}, comment: "÷ [0.2] (CR) ÷ [3.1] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0x3a}, expected: [][]byte{{0xd}, {0x3a}}, comment: "÷ [0.2] (CR) ÷ [3.1] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd, 0x2c}, expected: [][]byte{{0xd}, {0x2c}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd, 0x2e}, expected: [][]byte{{0xd}, {0x2e}}, comment: "÷ [0.2] (CR) ÷ [3.1] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xd, 0x30}, expected: [][]byte{{0xd}, {0x30}}, comment: "÷ [0.2] (CR) ÷ [3.1] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xd, 0x5f}, expected: [][]byte{{0xd}, {0x5f}}, comment: "÷ [0.2] (CR) ÷ [3.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xd, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xd}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (CR) ÷ [3.1] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xd, 0xd7, 0x90}, expected: [][]byte{{0xd}, {0xd7, 0x90}}, comment: "÷ [0.2] (CR) ÷ [3.1] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xd, 0x22}, expected: [][]byte{{0xd}, {0x22}}, comment: "÷ [0.2] (CR) ÷ [3.1] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xd, 0x27}, expected: [][]byte{{0xd}, {0x27}}, comment: "÷ [0.2] (CR) ÷ [3.1] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xd}, {0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (CR) ÷ [3.1] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xd}, {0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xd, 0xc2, 0xa9}, expected: [][]byte{{0xd}, {0xc2, 0xa9}}, comment: "÷ [0.2] (CR) ÷ [3.1] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xd, 0x20}, expected: [][]byte{{0xd}, {0x20}}, comment: "÷ [0.2] (CR) ÷ [3.1] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xd, 0x0}, expected: [][]byte{{0xd}, {0x0}}, comment: "÷ [0.2] (CR) ÷ [3.1] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xd, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (CR) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd, 0x61, 0x3a}, expected: [][]byte{{0xd}, {0x61}, {0x3a}}, comment: "÷ [0.2] (CR) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd, 0x61, 0x27}, expected: [][]byte{{0xd}, {0x61}, {0x27}}, comment: "÷ [0.2] (CR) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (CR) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd, 0x61, 0x2c}, expected: [][]byte{{0xd}, {0x61}, {0x2c}}, comment: "÷ [0.2] (CR) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd, 0x31, 0x3a}, expected: [][]byte{{0xd}, {0x31}, {0x3a}}, comment: "÷ [0.2] (CR) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd, 0x31, 0x27}, expected: [][]byte{{0xd}, {0x31}, {0x27}}, comment: "÷ [0.2] (CR) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd, 0x31, 0x2c}, expected: [][]byte{{0xd}, {0x31}, {0x2c}}, comment: "÷ [0.2] (CR) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (CR) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd}, {0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (CR) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xa, 0xd}, expected: [][]byte{{0xa}, {0xd}}, comment: "÷ [0.2] (LF) ÷ [3.1] (CR) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xa, 0xa}, expected: [][]byte{{0xa}, {0xa}}, comment: "÷ [0.2] (LF) ÷ [3.1] (LF) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xa, 0xb}, expected: [][]byte{{0xa}, {0xb}}, comment: "÷ [0.2] (LF) ÷ [3.1] (Newline) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x80}, expected: [][]byte{{0xa}, {0xcc, 0x80}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xa, 0xc2, 0xad}, expected: [][]byte{{0xa}, {0xc2, 0xad}}, comment: "÷ [0.2] (LF) ÷ [3.1] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xa, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xa}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] (LF) ÷ [3.1] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xa, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xa}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] (LF) ÷ [3.1] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0x41}, expected: [][]byte{{0xa}, {0x41}}, comment: "÷ [0.2] (LF) ÷ [3.1] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0x3a}, expected: [][]byte{{0xa}, {0x3a}}, comment: "÷ [0.2] (LF) ÷ [3.1] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xa, 0x2c}, expected: [][]byte{{0xa}, {0x2c}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xa, 0x2e}, expected: [][]byte{{0xa}, {0x2e}}, comment: "÷ [0.2] (LF) ÷ [3.1] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xa, 0x30}, expected: [][]byte{{0xa}, {0x30}}, comment: "÷ [0.2] (LF) ÷ [3.1] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xa, 0x5f}, expected: [][]byte{{0xa}, {0x5f}}, comment: "÷ [0.2] (LF) ÷ [3.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xa, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xa}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (LF) ÷ [3.1] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xa, 0xd7, 0x90}, expected: [][]byte{{0xa}, {0xd7, 0x90}}, comment: "÷ [0.2] (LF) ÷ [3.1] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xa, 0x22}, expected: [][]byte{{0xa}, {0x22}}, comment: "÷ [0.2] (LF) ÷ [3.1] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xa, 0x27}, expected: [][]byte{{0xa}, {0x27}}, comment: "÷ [0.2] (LF) ÷ [3.1] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xa, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xa}, {0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (LF) ÷ [3.1] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xa}, {0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xa, 0xc2, 0xa9}, expected: [][]byte{{0xa}, {0xc2, 0xa9}}, comment: "÷ [0.2] (LF) ÷ [3.1] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xa, 0x20}, expected: [][]byte{{0xa}, {0x20}}, comment: "÷ [0.2] (LF) ÷ [3.1] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xa, 0x0}, expected: [][]byte{{0xa}, {0x0}}, comment: "÷ [0.2] (LF) ÷ [3.1] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xa, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xa}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (LF) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xa, 0x61, 0x3a}, expected: [][]byte{{0xa}, {0x61}, {0x3a}}, comment: "÷ [0.2] (LF) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xa, 0x61, 0x27}, expected: [][]byte{{0xa}, {0x61}, {0x27}}, comment: "÷ [0.2] (LF) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xa, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xa}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (LF) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xa, 0x61, 0x2c}, expected: [][]byte{{0xa}, {0x61}, {0x2c}}, comment: "÷ [0.2] (LF) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xa, 0x31, 0x3a}, expected: [][]byte{{0xa}, {0x31}, {0x3a}}, comment: "÷ [0.2] (LF) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xa, 0x31, 0x27}, expected: [][]byte{{0xa}, {0x31}, {0x27}}, comment: "÷ [0.2] (LF) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xa, 0x31, 0x2c}, expected: [][]byte{{0xa}, {0x31}, {0x2c}}, comment: "÷ [0.2] (LF) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xa, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xa}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (LF) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xa, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xa}, {0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xb, 0xd}, expected: [][]byte{{0xb}, {0xd}}, comment: "÷ [0.2] (Newline) ÷ [3.1] (CR) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xb, 0xa}, expected: [][]byte{{0xb}, {0xa}}, comment: "÷ [0.2] (Newline) ÷ [3.1] (LF) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xb, 0xb}, expected: [][]byte{{0xb}, {0xb}}, comment: "÷ [0.2] (Newline) ÷ [3.1] (Newline) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x80}, expected: [][]byte{{0xb}, {0xcc, 0x80}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xb}, {0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xb, 0xc2, 0xad}, expected: [][]byte{{0xb}, {0xc2, 0xad}}, comment: "÷ [0.2] (Newline) ÷ [3.1] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xb}, {0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xb, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xb}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] (Newline) ÷ [3.1] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xb, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xb}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] (Newline) ÷ [3.1] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xb, 0x41}, expected: [][]byte{{0xb}, {0x41}}, comment: "÷ [0.2] (Newline) ÷ [3.1] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xb, 0x3a}, expected: [][]byte{{0xb}, {0x3a}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xb, 0x2c}, expected: [][]byte{{0xb}, {0x2c}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xb, 0x2e}, expected: [][]byte{{0xb}, {0x2e}}, comment: "÷ [0.2] (Newline) ÷ [3.1] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xb, 0x30}, expected: [][]byte{{0xb}, {0x30}}, comment: "÷ [0.2] (Newline) ÷ [3.1] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xb, 0x5f}, expected: [][]byte{{0xb}, {0x5f}}, comment: "÷ [0.2] (Newline) ÷ [3.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xb, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xb}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (Newline) ÷ [3.1] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xb, 0xd7, 0x90}, expected: [][]byte{{0xb}, {0xd7, 0x90}}, comment: "÷ [0.2] (Newline) ÷ [3.1] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xb, 0x22}, expected: [][]byte{{0xb}, {0x22}}, comment: "÷ [0.2] (Newline) ÷ [3.1] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xb, 0x27}, expected: [][]byte{{0xb}, {0x27}}, comment: "÷ [0.2] (Newline) ÷ [3.1] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xb, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xb}, {0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (Newline) ÷ [3.1] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xb}, {0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xb, 0xc2, 0xa9}, expected: [][]byte{{0xb}, {0xc2, 0xa9}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xb, 0x20}, expected: [][]byte{{0xb}, {0x20}}, comment: "÷ [0.2] (Newline) ÷ [3.1] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xb, 0x0}, expected: [][]byte{{0xb}, {0x0}}, comment: "÷ [0.2] (Newline) ÷ [3.1] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xb, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xb}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xb, 0x61, 0x3a}, expected: [][]byte{{0xb}, {0x61}, {0x3a}}, comment: "÷ [0.2] (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xb, 0x61, 0x27}, expected: [][]byte{{0xb}, {0x61}, {0x27}}, comment: "÷ [0.2] (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xb, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xb}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xb, 0x61, 0x2c}, expected: [][]byte{{0xb}, {0x61}, {0x2c}}, comment: "÷ [0.2] (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xb, 0x31, 0x3a}, expected: [][]byte{{0xb}, {0x31}, {0x3a}}, comment: "÷ [0.2] (Newline) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xb, 0x31, 0x27}, expected: [][]byte{{0xb}, {0x31}, {0x27}}, comment: "÷ [0.2] (Newline) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xb, 0x31, 0x2c}, expected: [][]byte{{0xb}, {0x31}, {0x2c}}, comment: "÷ [0.2] (Newline) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xb, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xb}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (Newline) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xb, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xb}, {0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xd}, expected: [][]byte{{0xcc, 0x80}, {0xd}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xa}, expected: [][]byte{{0xcc, 0x80}, {0xa}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xb}, expected: [][]byte{{0xcc, 0x80}, {0xb}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x80}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xc2, 0xad}, expected: [][]byte{{0xcc, 0x80, 0xc2, 0xad}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xcc, 0x80}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xcc, 0x80}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x41}, expected: [][]byte{{0xcc, 0x80}, {0x41}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x3a}, expected: [][]byte{{0xcc, 0x80}, {0x3a}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x2c}, expected: [][]byte{{0xcc, 0x80}, {0x2c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x2e}, expected: [][]byte{{0xcc, 0x80}, {0x2e}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x30}, expected: [][]byte{{0xcc, 0x80}, {0x30}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x5f}, expected: [][]byte{{0xcc, 0x80}, {0x5f}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xcc, 0x80}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xd7, 0x90}, expected: [][]byte{{0xcc, 0x80}, {0xd7, 0x90}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x22}, expected: [][]byte{{0xcc, 0x80}, {0x22}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x27}, expected: [][]byte{{0xcc, 0x80}, {0x27}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xcc, 0x80, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xc2, 0xa9}, expected: [][]byte{{0xcc, 0x80}, {0xc2, 0xa9}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x20}, expected: [][]byte{{0xcc, 0x80}, {0x20}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x0}, expected: [][]byte{{0xcc, 0x80}, {0x0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xcc, 0x80}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x61, 0x3a}, expected: [][]byte{{0xcc, 0x80}, {0x61}, {0x3a}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x61, 0x27}, expected: [][]byte{{0xcc, 0x80}, {0x61}, {0x27}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xcc, 0x80}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x61, 0x2c}, expected: [][]byte{{0xcc, 0x80}, {0x61}, {0x2c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x31, 0x3a}, expected: [][]byte{{0xcc, 0x80}, {0x31}, {0x3a}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x31, 0x27}, expected: [][]byte{{0xcc, 0x80}, {0x31}, {0x27}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x31, 0x2c}, expected: [][]byte{{0xcc, 0x80}, {0x31}, {0x2c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xcc, 0x80}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xcc, 0x80, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xcc, 0x80, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMBINING GRAVE ACCENT (Extend) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xd}, expected: [][]byte{{0xc2, 0xad}, {0xd}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xa}, expected: [][]byte{{0xc2, 0xad}, {0xa}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xb}, expected: [][]byte{{0xc2, 0xad}, {0xb}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x80}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xc2, 0xad}, expected: [][]byte{{0xc2, 0xad, 0xc2, 0xad}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xc2, 0xad}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xc2, 0xad}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x41}, expected: [][]byte{{0xc2, 0xad}, {0x41}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x3a}, expected: [][]byte{{0xc2, 0xad}, {0x3a}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x2c}, expected: [][]byte{{0xc2, 0xad}, {0x2c}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x2e}, expected: [][]byte{{0xc2, 0xad}, {0x2e}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x30}, expected: [][]byte{{0xc2, 0xad}, {0x30}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x5f}, expected: [][]byte{{0xc2, 0xad}, {0x5f}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xc2, 0xad}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xd7, 0x90}, expected: [][]byte{{0xc2, 0xad}, {0xd7, 0x90}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x22}, expected: [][]byte{{0xc2, 0xad}, {0x22}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x27}, expected: [][]byte{{0xc2, 0xad}, {0x27}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xc2, 0xad, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xc2, 0xa9}, expected: [][]byte{{0xc2, 0xad}, {0xc2, 0xa9}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x20}, expected: [][]byte{{0xc2, 0xad}, {0x20}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x0}, expected: [][]byte{{0xc2, 0xad}, {0x0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xad}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x61, 0x3a}, expected: [][]byte{{0xc2, 0xad}, {0x61}, {0x3a}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x61, 0x27}, expected: [][]byte{{0xc2, 0xad}, {0x61}, {0x27}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xad}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x61, 0x2c}, expected: [][]byte{{0xc2, 0xad}, {0x61}, {0x2c}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x31, 0x3a}, expected: [][]byte{{0xc2, 0xad}, {0x31}, {0x3a}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x31, 0x27}, expected: [][]byte{{0xc2, 0xad}, {0x31}, {0x27}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x31, 0x2c}, expected: [][]byte{{0xc2, 0xad}, {0x31}, {0x2c}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xad}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xad, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xad, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SOFT HYPHEN (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xd}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0xd}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xa}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0xa}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xb}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0xb}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x80}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x80}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xc2, 0xad}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xc2, 0xad}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [13.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) × [13.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x41}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x41}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x3a}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x3a}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x2c}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x2c}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x2e}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x2e}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x30}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x30}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x5f}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0x5f}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x5f}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xd7, 0x90}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0xd7, 0x90}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x22}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x22}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x27}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x27}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xc2, 0xa9}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0xc2, 0xa9}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x20}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x20}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x0}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x0}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x61, 0x3a}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x61}, {0x3a}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x61, 0x27}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x61}, {0x27}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x61, 0x2c}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x61}, {0x2c}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x31, 0x3a}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x31}, {0x3a}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x31, 0x27}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x31}, {0x27}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x31, 0x2c}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x31}, {0x2c}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe3, 0x80, 0xb1}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xd}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0xd}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xa}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0xa}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xb}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0xb}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x80}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x80}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xc2, 0xad}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xc2, 0xad}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [5.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x41}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x41}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x3a}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0x3a}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x2c}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0x2c}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x2e}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0x2e}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x30}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x30}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x5f}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x5f}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x5f}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xd7, 0x90}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xd7, 0x90}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [5.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x22}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0x22}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x27}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0x27}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xc2, 0xa9}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0xc2, 0xa9}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x20}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0x20}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x0}, expected: [][]byte{{0xe2, 0x93, 0x82}, {0x0}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x61, 0x3a}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x61}, {0x3a}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x61, 0x27}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x61}, {0x27}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x61, 0x2c}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x61}, {0x2c}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x31, 0x3a}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x31}, {0x3a}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x31, 0x27}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x31}, {0x27}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x31, 0x2c}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x31}, {0x2c}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x93, 0x82, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x93, 0x82, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x41, 0xd}, expected: [][]byte{{0x41}, {0xd}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x41, 0xa}, expected: [][]byte{{0x41}, {0xa}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x41, 0xb}, expected: [][]byte{{0x41}, {0xb}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x80}, expected: [][]byte{{0x41, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x41, 0xc2, 0xad}, expected: [][]byte{{0x41, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x41, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x41}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x41, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x41, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0x41}, expected: [][]byte{{0x41, 0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0x3a}, expected: [][]byte{{0x41}, {0x3a}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x41, 0x2c}, expected: [][]byte{{0x41}, {0x2c}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x41, 0x2e}, expected: [][]byte{{0x41}, {0x2e}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x41, 0x30}, expected: [][]byte{{0x41, 0x30}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x41, 0x5f}, expected: [][]byte{{0x41, 0x5f}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x5f}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x41, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x41}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x41, 0xd7, 0x90}, expected: [][]byte{{0x41, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x41, 0x22}, expected: [][]byte{{0x41}, {0x22}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x41, 0x27}, expected: [][]byte{{0x41}, {0x27}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x41, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x41, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x41, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x41, 0xc2, 0xa9}, expected: [][]byte{{0x41}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x41, 0x20}, expected: [][]byte{{0x41}, {0x20}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x41, 0x0}, expected: [][]byte{{0x41}, {0x0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x41, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x41, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x41, 0x61, 0x3a}, expected: [][]byte{{0x41, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x41, 0x61, 0x27}, expected: [][]byte{{0x41, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x41, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x41, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x41, 0x61, 0x2c}, expected: [][]byte{{0x41, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x41, 0x31, 0x3a}, expected: [][]byte{{0x41, 0x31}, {0x3a}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x41, 0x31, 0x27}, expected: [][]byte{{0x41, 0x31}, {0x27}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x41, 0x31, 0x2c}, expected: [][]byte{{0x41, 0x31}, {0x2c}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x41, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x41, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x41, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x41, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x3a, 0xd}, expected: [][]byte{{0x3a}, {0xd}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x3a, 0xa}, expected: [][]byte{{0x3a}, {0xa}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x3a, 0xb}, expected: [][]byte{{0x3a}, {0xb}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x80}, expected: [][]byte{{0x3a, 0xcc, 0x80}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x3a, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x3a, 0xc2, 0xad}, expected: [][]byte{{0x3a, 0xc2, 0xad}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x3a, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x3a, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x3a}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x3a, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x3a}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x3a, 0x41}, expected: [][]byte{{0x3a}, {0x41}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x3a, 0x3a}, expected: [][]byte{{0x3a}, {0x3a}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x3a, 0x2c}, expected: [][]byte{{0x3a}, {0x2c}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x3a, 0x2e}, expected: [][]byte{{0x3a}, {0x2e}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x3a, 0x30}, expected: [][]byte{{0x3a}, {0x30}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x3a, 0x5f}, expected: [][]byte{{0x3a}, {0x5f}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x3a, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x3a}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x3a, 0xd7, 0x90}, expected: [][]byte{{0x3a}, {0xd7, 0x90}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x3a, 0x22}, expected: [][]byte{{0x3a}, {0x22}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x3a, 0x27}, expected: [][]byte{{0x3a}, {0x27}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x3a, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x3a, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x3a, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x3a, 0xc2, 0xa9}, expected: [][]byte{{0x3a}, {0xc2, 0xa9}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x3a, 0x20}, expected: [][]byte{{0x3a}, {0x20}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x3a, 0x0}, expected: [][]byte{{0x3a}, {0x0}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x3a, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x3a}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x3a, 0x61, 0x3a}, expected: [][]byte{{0x3a}, {0x61}, {0x3a}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x3a, 0x61, 0x27}, expected: [][]byte{{0x3a}, {0x61}, {0x27}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x3a, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x3a}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x3a, 0x61, 0x2c}, expected: [][]byte{{0x3a}, {0x61}, {0x2c}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x3a, 0x31, 0x3a}, expected: [][]byte{{0x3a}, {0x31}, {0x3a}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x3a, 0x31, 0x27}, expected: [][]byte{{0x3a}, {0x31}, {0x27}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x3a, 0x31, 0x2c}, expected: [][]byte{{0x3a}, {0x31}, {0x2c}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x3a, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x3a}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x3a, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x3a, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0xd}, expected: [][]byte{{0x2c}, {0xd}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x2c, 0xa}, expected: [][]byte{{0x2c}, {0xa}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x2c, 0xb}, expected: [][]byte{{0x2c}, {0xb}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x80}, expected: [][]byte{{0x2c, 0xcc, 0x80}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x2c, 0xc2, 0xad}, expected: [][]byte{{0x2c, 0xc2, 0xad}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x2c}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x2c, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x2c}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x2c, 0x41}, expected: [][]byte{{0x2c}, {0x41}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x2c, 0x3a}, expected: [][]byte{{0x2c}, {0x3a}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2c, 0x2c}, expected: [][]byte{{0x2c}, {0x2c}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2c, 0x2e}, expected: [][]byte{{0x2c}, {0x2e}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x2c, 0x30}, expected: [][]byte{{0x2c}, {0x30}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x2c, 0x5f}, expected: [][]byte{{0x2c}, {0x5f}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x2c, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x2c}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x2c, 0xd7, 0x90}, expected: [][]byte{{0x2c}, {0xd7, 0x90}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x2c, 0x22}, expected: [][]byte{{0x2c}, {0x22}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x2c, 0x27}, expected: [][]byte{{0x2c}, {0x27}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2c, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x2c, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x2c, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x2c, 0xc2, 0xa9}, expected: [][]byte{{0x2c}, {0xc2, 0xa9}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x2c, 0x20}, expected: [][]byte{{0x2c}, {0x20}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x2c, 0x0}, expected: [][]byte{{0x2c}, {0x0}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x2c, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2c}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0x61, 0x3a}, expected: [][]byte{{0x2c}, {0x61}, {0x3a}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2c, 0x61, 0x27}, expected: [][]byte{{0x2c}, {0x61}, {0x27}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2c, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2c}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0x61, 0x2c}, expected: [][]byte{{0x2c}, {0x61}, {0x2c}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2c, 0x31, 0x3a}, expected: [][]byte{{0x2c}, {0x31}, {0x3a}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2c, 0x31, 0x27}, expected: [][]byte{{0x2c}, {0x31}, {0x27}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2c, 0x31, 0x2c}, expected: [][]byte{{0x2c}, {0x31}, {0x2c}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2c, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2c}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2c, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2c, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0xd}, expected: [][]byte{{0x2e}, {0xd}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x2e, 0xa}, expected: [][]byte{{0x2e}, {0xa}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x2e, 0xb}, expected: [][]byte{{0x2e}, {0xb}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x80}, expected: [][]byte{{0x2e, 0xcc, 0x80}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x2e, 0xc2, 0xad}, expected: [][]byte{{0x2e, 0xc2, 0xad}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x2e}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x2e, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x2e}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x2e, 0x41}, expected: [][]byte{{0x2e}, {0x41}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x2e, 0x3a}, expected: [][]byte{{0x2e}, {0x3a}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2e, 0x2c}, expected: [][]byte{{0x2e}, {0x2c}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2e, 0x2e}, expected: [][]byte{{0x2e}, {0x2e}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x2e, 0x30}, expected: [][]byte{{0x2e}, {0x30}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x2e, 0x5f}, expected: [][]byte{{0x2e}, {0x5f}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x2e, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x2e}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x2e, 0xd7, 0x90}, expected: [][]byte{{0x2e}, {0xd7, 0x90}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x2e, 0x22}, expected: [][]byte{{0x2e}, {0x22}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x2e, 0x27}, expected: [][]byte{{0x2e}, {0x27}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2e, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x2e, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x2e, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x2e, 0xc2, 0xa9}, expected: [][]byte{{0x2e}, {0xc2, 0xa9}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x2e, 0x20}, expected: [][]byte{{0x2e}, {0x20}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x2e, 0x0}, expected: [][]byte{{0x2e}, {0x0}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x2e, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2e}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0x61, 0x3a}, expected: [][]byte{{0x2e}, {0x61}, {0x3a}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2e, 0x61, 0x27}, expected: [][]byte{{0x2e}, {0x61}, {0x27}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2e, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2e}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0x61, 0x2c}, expected: [][]byte{{0x2e}, {0x61}, {0x2c}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2e, 0x31, 0x3a}, expected: [][]byte{{0x2e}, {0x31}, {0x3a}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x2e, 0x31, 0x27}, expected: [][]byte{{0x2e}, {0x31}, {0x27}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x2e, 0x31, 0x2c}, expected: [][]byte{{0x2e}, {0x31}, {0x2c}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x2e, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2e}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x2e, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x2e, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] FULL STOP (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x30, 0xd}, expected: [][]byte{{0x30}, {0xd}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x30, 0xa}, expected: [][]byte{{0x30}, {0xa}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x30, 0xb}, expected: [][]byte{{0x30}, {0xb}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x80}, expected: [][]byte{{0x30, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x30, 0xc2, 0xad}, expected: [][]byte{{0x30, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x30, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x30}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x30, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x30, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [10.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [10.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x30, 0x41}, expected: [][]byte{{0x30, 0x41}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [10.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x30, 0x3a}, expected: [][]byte{{0x30}, {0x3a}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x30, 0x2c}, expected: [][]byte{{0x30}, {0x2c}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x30, 0x2e}, expected: [][]byte{{0x30}, {0x2e}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x30, 0x30}, expected: [][]byte{{0x30, 0x30}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [8.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x30, 0x5f}, expected: [][]byte{{0x30, 0x5f}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x5f}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x30, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x30}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x30, 0xd7, 0x90}, expected: [][]byte{{0x30, 0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [10.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [10.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x30, 0x22}, expected: [][]byte{{0x30}, {0x22}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x30, 0x27}, expected: [][]byte{{0x30}, {0x27}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x30, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x30, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x30, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x30, 0xc2, 0xa9}, expected: [][]byte{{0x30}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x30, 0x20}, expected: [][]byte{{0x30}, {0x20}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x30, 0x0}, expected: [][]byte{{0x30}, {0x0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x30, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x30, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x30, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x30, 0x61, 0x3a}, expected: [][]byte{{0x30, 0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x30, 0x61, 0x27}, expected: [][]byte{{0x30, 0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x30, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x30, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x30, 0x61, 0x2c}, expected: [][]byte{{0x30, 0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [10.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x30, 0x31, 0x3a}, expected: [][]byte{{0x30, 0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x30, 0x31, 0x27}, expected: [][]byte{{0x30, 0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x30, 0x31, 0x2c}, expected: [][]byte{{0x30, 0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x30, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x30, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x30, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x30, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x5f, 0xd}, expected: [][]byte{{0x5f}, {0xd}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x5f, 0xa}, expected: [][]byte{{0x5f}, {0xa}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x5f, 0xb}, expected: [][]byte{{0x5f}, {0xb}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x80}, expected: [][]byte{{0x5f, 0xcc, 0x80}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x5f, 0xc2, 0xad}, expected: [][]byte{{0x5f, 0xc2, 0xad}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x5f, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x5f, 0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x5f, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x5f, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x5f, 0x41}, expected: [][]byte{{0x5f, 0x41}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x5f, 0x3a}, expected: [][]byte{{0x5f}, {0x3a}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x5f, 0x2c}, expected: [][]byte{{0x5f}, {0x2c}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x5f, 0x2e}, expected: [][]byte{{0x5f}, {0x2e}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x5f, 0x30}, expected: [][]byte{{0x5f, 0x30}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x5f, 0x5f}, expected: [][]byte{{0x5f, 0x5f}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x5f}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x5f, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x5f}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x5f, 0xd7, 0x90}, expected: [][]byte{{0x5f, 0xd7, 0x90}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x5f, 0x22}, expected: [][]byte{{0x5f}, {0x22}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x5f, 0x27}, expected: [][]byte{{0x5f}, {0x27}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x5f, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x5f, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x5f, 0xc2, 0xa9}, expected: [][]byte{{0x5f}, {0xc2, 0xa9}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x5f, 0x20}, expected: [][]byte{{0x5f}, {0x20}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x5f, 0x0}, expected: [][]byte{{0x5f}, {0x0}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x5f, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x5f, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x5f, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x5f, 0x61, 0x3a}, expected: [][]byte{{0x5f, 0x61}, {0x3a}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x5f, 0x61, 0x27}, expected: [][]byte{{0x5f, 0x61}, {0x27}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x5f, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x5f, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x5f, 0x61, 0x2c}, expected: [][]byte{{0x5f, 0x61}, {0x2c}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x5f, 0x31, 0x3a}, expected: [][]byte{{0x5f, 0x31}, {0x3a}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x5f, 0x31, 0x27}, expected: [][]byte{{0x5f, 0x31}, {0x27}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x5f, 0x31, 0x2c}, expected: [][]byte{{0x5f, 0x31}, {0x2c}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x5f, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x5f, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x5f, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x5f, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xd}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xd}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xa}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xa}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xb}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xb}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x80}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x80}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xc2, 0xad}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xc2, 0xad}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x41}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x41}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x3a}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x3a}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x2c}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x2c}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x2e}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x2e}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x30}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x30}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x5f}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x5f}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [15.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) × [15.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xd7, 0x90}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xd7, 0x90}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x22}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x22}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x27}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x27}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xc2, 0xa9}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0xc2, 0xa9}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x20}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x20}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x61, 0x3a}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x61}, {0x3a}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x61, 0x27}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x61}, {0x27}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x61, 0x2c}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x61}, {0x2c}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x31, 0x3a}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x31}, {0x3a}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x31, 0x27}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x31}, {0x27}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x31, 0x2c}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x31}, {0x2c}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xd}, expected: [][]byte{{0xd7, 0x90}, {0xd}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xa}, expected: [][]byte{{0xd7, 0x90}, {0xa}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xb}, expected: [][]byte{{0xd7, 0x90}, {0xb}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x80}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x80}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xc2, 0xad}, expected: [][]byte{{0xd7, 0x90, 0xc2, 0xad}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xd7, 0x90}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xd7, 0x90, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [5.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x41}, expected: [][]byte{{0xd7, 0x90, 0x41}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x3a}, expected: [][]byte{{0xd7, 0x90}, {0x3a}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x2c}, expected: [][]byte{{0xd7, 0x90}, {0x2c}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x2e}, expected: [][]byte{{0xd7, 0x90}, {0x2e}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x30}, expected: [][]byte{{0xd7, 0x90, 0x30}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x5f}, expected: [][]byte{{0xd7, 0x90, 0x5f}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x5f}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xd7, 0x90}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xd7, 0x90}, expected: [][]byte{{0xd7, 0x90, 0xd7, 0x90}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [5.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x22}, expected: [][]byte{{0xd7, 0x90}, {0x22}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x27}, expected: [][]byte{{0xd7, 0x90, 0x27}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [7.1] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x27}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [7.1] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xd7, 0x90, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xc2, 0xa9}, expected: [][]byte{{0xd7, 0x90}, {0xc2, 0xa9}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x20}, expected: [][]byte{{0xd7, 0x90}, {0x20}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x0}, expected: [][]byte{{0xd7, 0x90}, {0x0}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd7, 0x90, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x61, 0x3a}, expected: [][]byte{{0xd7, 0x90, 0x61}, {0x3a}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x61, 0x27}, expected: [][]byte{{0xd7, 0x90, 0x61}, {0x27}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd7, 0x90, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x61, 0x2c}, expected: [][]byte{{0xd7, 0x90, 0x61}, {0x2c}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x31, 0x3a}, expected: [][]byte{{0xd7, 0x90, 0x31}, {0x3a}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x31, 0x27}, expected: [][]byte{{0xd7, 0x90, 0x31}, {0x27}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x31, 0x2c}, expected: [][]byte{{0xd7, 0x90, 0x31}, {0x2c}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd7, 0x90, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xd7, 0x90, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x22, 0xd}, expected: [][]byte{{0x22}, {0xd}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x22, 0xa}, expected: [][]byte{{0x22}, {0xa}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x22, 0xb}, expected: [][]byte{{0x22}, {0xb}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x80}, expected: [][]byte{{0x22, 0xcc, 0x80}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x22, 0xc2, 0xad}, expected: [][]byte{{0x22, 0xc2, 0xad}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x22, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x22}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x22, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x22}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x22, 0x41}, expected: [][]byte{{0x22}, {0x41}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x22, 0x3a}, expected: [][]byte{{0x22}, {0x3a}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x22, 0x2c}, expected: [][]byte{{0x22}, {0x2c}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x22, 0x2e}, expected: [][]byte{{0x22}, {0x2e}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x22, 0x30}, expected: [][]byte{{0x22}, {0x30}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x22, 0x5f}, expected: [][]byte{{0x22}, {0x5f}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x22, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x22}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x22, 0xd7, 0x90}, expected: [][]byte{{0x22}, {0xd7, 0x90}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x22, 0x22}, expected: [][]byte{{0x22}, {0x22}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x22, 0x27}, expected: [][]byte{{0x22}, {0x27}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x22, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x22, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x22, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x22, 0xc2, 0xa9}, expected: [][]byte{{0x22}, {0xc2, 0xa9}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x22, 0x20}, expected: [][]byte{{0x22}, {0x20}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x22, 0x0}, expected: [][]byte{{0x22}, {0x0}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x22, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x22}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x22, 0x61, 0x3a}, expected: [][]byte{{0x22}, {0x61}, {0x3a}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x22, 0x61, 0x27}, expected: [][]byte{{0x22}, {0x61}, {0x27}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x22, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x22}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x22, 0x61, 0x2c}, expected: [][]byte{{0x22}, {0x61}, {0x2c}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x22, 0x31, 0x3a}, expected: [][]byte{{0x22}, {0x31}, {0x3a}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x22, 0x31, 0x27}, expected: [][]byte{{0x22}, {0x31}, {0x27}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x22, 0x31, 0x2c}, expected: [][]byte{{0x22}, {0x31}, {0x2c}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x22, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x22}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x22, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x22, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] QUOTATION MARK (Double_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x27, 0xd}, expected: [][]byte{{0x27}, {0xd}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x27, 0xa}, expected: [][]byte{{0x27}, {0xa}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x27, 0xb}, expected: [][]byte{{0x27}, {0xb}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x80}, expected: [][]byte{{0x27, 0xcc, 0x80}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x27, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x27, 0xc2, 0xad}, expected: [][]byte{{0x27, 0xc2, 0xad}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x27, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x27, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x27}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x27, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x27}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x27, 0x41}, expected: [][]byte{{0x27}, {0x41}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x27, 0x3a}, expected: [][]byte{{0x27}, {0x3a}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x27, 0x2c}, expected: [][]byte{{0x27}, {0x2c}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x27, 0x2e}, expected: [][]byte{{0x27}, {0x2e}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x27, 0x30}, expected: [][]byte{{0x27}, {0x30}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x27, 0x5f}, expected: [][]byte{{0x27}, {0x5f}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x27, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x27}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x27, 0xd7, 0x90}, expected: [][]byte{{0x27}, {0xd7, 0x90}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x27, 0x22}, expected: [][]byte{{0x27}, {0x22}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x27, 0x27}, expected: [][]byte{{0x27}, {0x27}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x27, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x27, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x27, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x27, 0xc2, 0xa9}, expected: [][]byte{{0x27}, {0xc2, 0xa9}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x27, 0x20}, expected: [][]byte{{0x27}, {0x20}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x27, 0x0}, expected: [][]byte{{0x27}, {0x0}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x27, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x27}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x27, 0x61, 0x3a}, expected: [][]byte{{0x27}, {0x61}, {0x3a}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x27, 0x61, 0x27}, expected: [][]byte{{0x27}, {0x61}, {0x27}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x27, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x27}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x27, 0x61, 0x2c}, expected: [][]byte{{0x27}, {0x61}, {0x2c}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x27, 0x31, 0x3a}, expected: [][]byte{{0x27}, {0x31}, {0x3a}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x27, 0x31, 0x27}, expected: [][]byte{{0x27}, {0x31}, {0x27}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x27, 0x31, 0x2c}, expected: [][]byte{{0x27}, {0x31}, {0x2c}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x27, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x27}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x27, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x27, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xd}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xd}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xa}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xa}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xb}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xb}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x80}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xc2, 0xad}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xc2, 0xad}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [3.3] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x41}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x41}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x3a}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x3a}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x2c}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x2c}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x2e}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x2e}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x30}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x30}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x5f}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x5f}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xd7, 0x90}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0xd7, 0x90}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x22}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x22}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x27}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x27}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xc2, 0xa9}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xc2, 0xa9}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [3.3] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x20}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x20}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x0}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x61, 0x3a}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x61}, {0x3a}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x61, 0x27}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x61}, {0x27}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x61, 0x2c}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x61}, {0x2c}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x31, 0x3a}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x31}, {0x3a}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x31, 0x27}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x31}, {0x27}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x31, 0x2c}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x31}, {0x2c}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8d}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xd}, expected: [][]byte{{0xc2, 0xa9}, {0xd}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xd}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xa}, expected: [][]byte{{0xc2, 0xa9}, {0xa}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xa}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xb}, expected: [][]byte{{0xc2, 0xa9}, {0xb}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xb}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x80}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xc2, 0xad}, expected: [][]byte{{0xc2, 0xa9, 0xc2, 0xad}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xc2, 0xa9}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xc2, 0xa9}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x41}, expected: [][]byte{{0xc2, 0xa9}, {0x41}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x41}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x3a}, expected: [][]byte{{0xc2, 0xa9}, {0x3a}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x2c}, expected: [][]byte{{0xc2, 0xa9}, {0x2c}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x2e}, expected: [][]byte{{0xc2, 0xa9}, {0x2e}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x30}, expected: [][]byte{{0xc2, 0xa9}, {0x30}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x30}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x5f}, expected: [][]byte{{0xc2, 0xa9}, {0x5f}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xc2, 0xa9}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xd7, 0x90}, expected: [][]byte{{0xc2, 0xa9}, {0xd7, 0x90}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x22}, expected: [][]byte{{0xc2, 0xa9}, {0x22}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x22}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x27}, expected: [][]byte{{0xc2, 0xa9}, {0x27}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x27}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xc2, 0xa9, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xc2, 0xa9}, expected: [][]byte{{0xc2, 0xa9}, {0xc2, 0xa9}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x20}, expected: [][]byte{{0xc2, 0xa9}, {0x20}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x20}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x0}, expected: [][]byte{{0xc2, 0xa9}, {0x0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x0}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xa9}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x61, 0x3a}, expected: [][]byte{{0xc2, 0xa9}, {0x61}, {0x3a}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x61, 0x27}, expected: [][]byte{{0xc2, 0xa9}, {0x61}, {0x27}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xa9}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x61, 0x2c}, expected: [][]byte{{0xc2, 0xa9}, {0x61}, {0x2c}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x31, 0x3a}, expected: [][]byte{{0xc2, 0xa9}, {0x31}, {0x3a}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x31, 0x27}, expected: [][]byte{{0xc2, 0xa9}, {0x31}, {0x27}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x31, 0x2c}, expected: [][]byte{{0xc2, 0xa9}, {0x31}, {0x2c}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xa9}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xc2, 0xa9, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0xc2, 0xa9, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] COPYRIGHT SIGN (ExtPictmALetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x20, 0xd}, expected: [][]byte{{0x20}, {0xd}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x20, 0xa}, expected: [][]byte{{0x20}, {0xa}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x20, 0xb}, expected: [][]byte{{0x20}, {0xb}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x80}, expected: [][]byte{{0x20, 0xcc, 0x80}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x20, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x20, 0xc2, 0xad}, expected: [][]byte{{0x20, 0xc2, 0xad}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x20, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x20, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x20}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x20, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x20}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0x41}, expected: [][]byte{{0x20}, {0x41}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0x3a}, expected: [][]byte{{0x20}, {0x3a}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x20, 0x2c}, expected: [][]byte{{0x20}, {0x2c}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x20, 0x2e}, expected: [][]byte{{0x20}, {0x2e}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x20, 0x30}, expected: [][]byte{{0x20}, {0x30}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x20, 0x5f}, expected: [][]byte{{0x20}, {0x5f}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x20, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x20}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x20, 0xd7, 0x90}, expected: [][]byte{{0x20}, {0xd7, 0x90}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x20, 0x22}, expected: [][]byte{{0x20}, {0x22}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x20, 0x27}, expected: [][]byte{{0x20}, {0x27}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x20, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x20, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x20, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x20, 0xc2, 0xa9}, expected: [][]byte{{0x20}, {0xc2, 0xa9}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x20, 0x20}, expected: [][]byte{{0x20, 0x20}}, comment: "÷ [0.2] SPACE (WSegSpace) × [3.4] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x20, 0x0}, expected: [][]byte{{0x20}, {0x0}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x20, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x20}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x20, 0x61, 0x3a}, expected: [][]byte{{0x20}, {0x61}, {0x3a}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x20, 0x61, 0x27}, expected: [][]byte{{0x20}, {0x61}, {0x27}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x20, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x20}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x20, 0x61, 0x2c}, expected: [][]byte{{0x20}, {0x61}, {0x2c}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x20, 0x31, 0x3a}, expected: [][]byte{{0x20}, {0x31}, {0x3a}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x20, 0x31, 0x27}, expected: [][]byte{{0x20}, {0x31}, {0x27}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x20, 0x31, 0x2c}, expected: [][]byte{{0x20}, {0x31}, {0x2c}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x20, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x20}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x20, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x20, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x0, 0xd}, expected: [][]byte{{0x0}, {0xd}}, comment: "÷ [0.2] (XXmExtPict) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x0, 0xa}, expected: [][]byte{{0x0}, {0xa}}, comment: "÷ [0.2] (XXmExtPict) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x0, 0xb}, expected: [][]byte{{0x0}, {0xb}}, comment: "÷ [0.2] (XXmExtPict) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x80}, expected: [][]byte{{0x0, 0xcc, 0x80}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x0, 0xc2, 0xad}, expected: [][]byte{{0x0, 0xc2, 0xad}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x0, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x0}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x0, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x0}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0x41}, expected: [][]byte{{0x0}, {0x41}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0x3a}, expected: [][]byte{{0x0}, {0x3a}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x0, 0x2c}, expected: [][]byte{{0x0}, {0x2c}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x0, 0x2e}, expected: [][]byte{{0x0}, {0x2e}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x0, 0x30}, expected: [][]byte{{0x0}, {0x30}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x0, 0x5f}, expected: [][]byte{{0x0}, {0x5f}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x0, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x0}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x0, 0xd7, 0x90}, expected: [][]byte{{0x0}, {0xd7, 0x90}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x0, 0x22}, expected: [][]byte{{0x0}, {0x22}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x0, 0x27}, expected: [][]byte{{0x0}, {0x27}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x0, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x0, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x0, 0xc2, 0xa9}, expected: [][]byte{{0x0}, {0xc2, 0xa9}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x0, 0x20}, expected: [][]byte{{0x0}, {0x20}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x0, 0x0}, expected: [][]byte{{0x0}, {0x0}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x0, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x0}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x0, 0x61, 0x3a}, expected: [][]byte{{0x0}, {0x61}, {0x3a}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x0, 0x61, 0x27}, expected: [][]byte{{0x0}, {0x61}, {0x27}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x0, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x0}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x0, 0x61, 0x2c}, expected: [][]byte{{0x0}, {0x61}, {0x2c}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x0, 0x31, 0x3a}, expected: [][]byte{{0x0}, {0x31}, {0x3a}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x0, 0x31, 0x27}, expected: [][]byte{{0x0}, {0x31}, {0x27}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x0, 0x31, 0x2c}, expected: [][]byte{{0x0}, {0x31}, {0x2c}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x0, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x0}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (XXmExtPict) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x0, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x0, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] (XXmExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xd}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xa}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xb}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x80}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xc2, 0xad}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [5.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x41}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x3a}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x2c}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x2e}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x30}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x5f}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xd7, 0x90}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [5.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x22}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x27}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xc2, 0xa9}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x20}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x0}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x61, 0x3a}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x61, 0x27}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x61, 0x2c}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x31, 0x3a}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x31, 0x27}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x31, 0x2c}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xd}, expected: [][]byte{{0x61}, {0x3a}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xa}, expected: [][]byte{{0x61}, {0x3a}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xb}, expected: [][]byte{{0x61}, {0x3a}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x80}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xc2, 0xad}, expected: [][]byte{{0x61}, {0x3a, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61}, {0x3a}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61, 0x3a, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61, 0x3a, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x41}, expected: [][]byte{{0x61, 0x3a, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x61, 0x3a, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x3a}, expected: [][]byte{{0x61}, {0x3a}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x2c}, expected: [][]byte{{0x61}, {0x3a}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x2e}, expected: [][]byte{{0x61}, {0x3a}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x30}, expected: [][]byte{{0x61}, {0x3a}, {0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x5f}, expected: [][]byte{{0x61}, {0x3a}, {0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61}, {0x3a}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xd7, 0x90}, expected: [][]byte{{0x61, 0x3a, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x61, 0x3a, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x22}, expected: [][]byte{{0x61}, {0x3a}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x27}, expected: [][]byte{{0x61}, {0x3a}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61}, {0x3a, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xc2, 0xa9}, expected: [][]byte{{0x61}, {0x3a}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x20}, expected: [][]byte{{0x61}, {0x3a}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x0}, expected: [][]byte{{0x61}, {0x3a}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x3a, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x3a, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x61, 0x3a}, expected: [][]byte{{0x61, 0x3a, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x61, 0x3a, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x61, 0x27}, expected: [][]byte{{0x61, 0x3a, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x61, 0x3a, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x3a, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x3a, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x61, 0x2c}, expected: [][]byte{{0x61, 0x3a, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x61, 0x3a, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x31, 0x3a}, expected: [][]byte{{0x61}, {0x3a}, {0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x31, 0x27}, expected: [][]byte{{0x61}, {0x3a}, {0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x31, 0x2c}, expected: [][]byte{{0x61}, {0x3a}, {0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x3a}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x3a, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xd}, expected: [][]byte{{0x61}, {0x27}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xa}, expected: [][]byte{{0x61}, {0x27}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xb}, expected: [][]byte{{0x61}, {0x27}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x80}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xc2, 0xad}, expected: [][]byte{{0x61}, {0x27, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61}, {0x27}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [7.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61, 0x27, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x41}, expected: [][]byte{{0x61, 0x27, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [7.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x61, 0x27, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x3a}, expected: [][]byte{{0x61}, {0x27}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x2c}, expected: [][]byte{{0x61}, {0x27}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x2e}, expected: [][]byte{{0x61}, {0x27}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x30}, expected: [][]byte{{0x61}, {0x27}, {0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x5f}, expected: [][]byte{{0x61}, {0x27}, {0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61}, {0x27}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xd7, 0x90}, expected: [][]byte{{0x61, 0x27, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [7.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x61, 0x27, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x22}, expected: [][]byte{{0x61}, {0x27}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x27}, expected: [][]byte{{0x61}, {0x27}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xc2, 0xa9}, expected: [][]byte{{0x61}, {0x27}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x20}, expected: [][]byte{{0x61}, {0x27}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x0}, expected: [][]byte{{0x61}, {0x27}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x27, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x27, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x61, 0x3a}, expected: [][]byte{{0x61, 0x27, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x61, 0x27, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x61, 0x27}, expected: [][]byte{{0x61, 0x27, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x61, 0x27, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x27, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x27, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x61, 0x2c}, expected: [][]byte{{0x61, 0x27, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x61, 0x27, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x31, 0x3a}, expected: [][]byte{{0x61}, {0x27}, {0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x31, 0x27}, expected: [][]byte{{0x61}, {0x27}, {0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x31, 0x2c}, expected: [][]byte{{0x61}, {0x27}, {0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x27}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x27, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xd}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xa}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xb}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x80}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xc2, 0xad}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [7.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x41}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [7.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x3a}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x2c}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x2e}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x30}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x5f}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xd7, 0x90}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [7.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x22}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x27}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xc2, 0xa9}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x20}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x0}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61, 0x3a}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61, 0x27}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61, 0x2c}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [6.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [7.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x31, 0x3a}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x31, 0x27}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x31, 0x2c}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x27, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xd}, expected: [][]byte{{0x61}, {0x2c}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xa}, expected: [][]byte{{0x61}, {0x2c}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xb}, expected: [][]byte{{0x61}, {0x2c}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x80}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xc2, 0xad}, expected: [][]byte{{0x61}, {0x2c, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61}, {0x2c}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61}, {0x2c}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x41}, expected: [][]byte{{0x61}, {0x2c}, {0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x3a}, expected: [][]byte{{0x61}, {0x2c}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x2c}, expected: [][]byte{{0x61}, {0x2c}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x2e}, expected: [][]byte{{0x61}, {0x2c}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x30}, expected: [][]byte{{0x61}, {0x2c}, {0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x5f}, expected: [][]byte{{0x61}, {0x2c}, {0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61}, {0x2c}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xd7, 0x90}, expected: [][]byte{{0x61}, {0x2c}, {0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x22}, expected: [][]byte{{0x61}, {0x2c}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x27}, expected: [][]byte{{0x61}, {0x2c}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61}, {0x2c, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xc2, 0xa9}, expected: [][]byte{{0x61}, {0x2c}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x20}, expected: [][]byte{{0x61}, {0x2c}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x0}, expected: [][]byte{{0x61}, {0x2c}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x2c}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x61, 0x3a}, expected: [][]byte{{0x61}, {0x2c}, {0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x61, 0x27}, expected: [][]byte{{0x61}, {0x2c}, {0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x2c}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x61, 0x2c}, expected: [][]byte{{0x61}, {0x2c}, {0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x31, 0x3a}, expected: [][]byte{{0x61}, {0x2c}, {0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x31, 0x27}, expected: [][]byte{{0x61}, {0x2c}, {0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x31, 0x2c}, expected: [][]byte{{0x61}, {0x2c}, {0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x2c}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x61}, {0x2c, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xd}, expected: [][]byte{{0x31}, {0x3a}, {0xd}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xa}, expected: [][]byte{{0x31}, {0x3a}, {0xa}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xb}, expected: [][]byte{{0x31}, {0x3a}, {0xb}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x80}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xc2, 0xad}, expected: [][]byte{{0x31}, {0x3a, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x31}, {0x3a}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x31}, {0x3a}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x41}, expected: [][]byte{{0x31}, {0x3a}, {0x41}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x3a}, expected: [][]byte{{0x31}, {0x3a}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x2c}, expected: [][]byte{{0x31}, {0x3a}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x2e}, expected: [][]byte{{0x31}, {0x3a}, {0x2e}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x30}, expected: [][]byte{{0x31}, {0x3a}, {0x30}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x30}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x5f}, expected: [][]byte{{0x31}, {0x3a}, {0x5f}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x31}, {0x3a}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xd7, 0x90}, expected: [][]byte{{0x31}, {0x3a}, {0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x22}, expected: [][]byte{{0x31}, {0x3a}, {0x22}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x27}, expected: [][]byte{{0x31}, {0x3a}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x31}, {0x3a, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xc2, 0xa9}, expected: [][]byte{{0x31}, {0x3a}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x20}, expected: [][]byte{{0x31}, {0x3a}, {0x20}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x0}, expected: [][]byte{{0x31}, {0x3a}, {0x0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x3a}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x61, 0x3a}, expected: [][]byte{{0x31}, {0x3a}, {0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x61, 0x27}, expected: [][]byte{{0x31}, {0x3a}, {0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x3a}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x61, 0x2c}, expected: [][]byte{{0x31}, {0x3a}, {0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x31, 0x3a}, expected: [][]byte{{0x31}, {0x3a}, {0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x31, 0x27}, expected: [][]byte{{0x31}, {0x3a}, {0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x31, 0x2c}, expected: [][]byte{{0x31}, {0x3a}, {0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x3a}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x3a, 0xcc, 0x88}, {0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xd}, expected: [][]byte{{0x31}, {0x27}, {0xd}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xa}, expected: [][]byte{{0x31}, {0x27}, {0xa}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xb}, expected: [][]byte{{0x31}, {0x27}, {0xb}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x80}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xc2, 0xad}, expected: [][]byte{{0x31}, {0x27, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x31}, {0x27}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x31}, {0x27}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x41}, expected: [][]byte{{0x31}, {0x27}, {0x41}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x3a}, expected: [][]byte{{0x31}, {0x27}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x2c}, expected: [][]byte{{0x31}, {0x27}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x2e}, expected: [][]byte{{0x31}, {0x27}, {0x2e}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x30}, expected: [][]byte{{0x31, 0x27, 0x30}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x31, 0x27, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x5f}, expected: [][]byte{{0x31}, {0x27}, {0x5f}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x31}, {0x27}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xd7, 0x90}, expected: [][]byte{{0x31}, {0x27}, {0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x22}, expected: [][]byte{{0x31}, {0x27}, {0x22}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x27}, expected: [][]byte{{0x31}, {0x27}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x31}, {0x27, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xc2, 0xa9}, expected: [][]byte{{0x31}, {0x27}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x20}, expected: [][]byte{{0x31}, {0x27}, {0x20}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x0}, expected: [][]byte{{0x31}, {0x27}, {0x0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x27}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x61, 0x3a}, expected: [][]byte{{0x31}, {0x27}, {0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x61, 0x27}, expected: [][]byte{{0x31}, {0x27}, {0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x27}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x61, 0x2c}, expected: [][]byte{{0x31}, {0x27}, {0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x31}, {0x27, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x31, 0x3a}, expected: [][]byte{{0x31, 0x27, 0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x31, 0x27, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x31, 0x27}, expected: [][]byte{{0x31, 0x27, 0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x31, 0x27, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x31, 0x2c}, expected: [][]byte{{0x31, 0x27, 0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x31, 0x27, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31, 0x27, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x27, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31, 0x27, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (Single_Quote) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xd}, expected: [][]byte{{0x31}, {0x2c}, {0xd}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xa}, expected: [][]byte{{0x31}, {0x2c}, {0xa}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xb}, expected: [][]byte{{0x31}, {0x2c}, {0xb}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x80}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xc2, 0xad}, expected: [][]byte{{0x31}, {0x2c, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x31}, {0x2c}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x31}, {0x2c}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x41}, expected: [][]byte{{0x31}, {0x2c}, {0x41}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x3a}, expected: [][]byte{{0x31}, {0x2c}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x2c}, expected: [][]byte{{0x31}, {0x2c}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x2e}, expected: [][]byte{{0x31}, {0x2c}, {0x2e}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x30}, expected: [][]byte{{0x31, 0x2c, 0x30}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x31, 0x2c, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x5f}, expected: [][]byte{{0x31}, {0x2c}, {0x5f}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x31}, {0x2c}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xd7, 0x90}, expected: [][]byte{{0x31}, {0x2c}, {0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x22}, expected: [][]byte{{0x31}, {0x2c}, {0x22}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x27}, expected: [][]byte{{0x31}, {0x2c}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x31}, {0x2c, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xc2, 0xa9}, expected: [][]byte{{0x31}, {0x2c}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x20}, expected: [][]byte{{0x31}, {0x2c}, {0x20}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x0}, expected: [][]byte{{0x31}, {0x2c}, {0x0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x2c}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x61, 0x3a}, expected: [][]byte{{0x31}, {0x2c}, {0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x61, 0x27}, expected: [][]byte{{0x31}, {0x2c}, {0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x2c}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x61, 0x2c}, expected: [][]byte{{0x31}, {0x2c}, {0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x31}, {0x2c, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x31, 0x3a}, expected: [][]byte{{0x31, 0x2c, 0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x31, 0x2c, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x31, 0x27}, expected: [][]byte{{0x31, 0x2c, 0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x31, 0x2c, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x31, 0x2c}, expected: [][]byte{{0x31, 0x2c, 0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x31, 0x2c, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31, 0x2c, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31, 0x2c, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xd}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0xd}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xd}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xd}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (CR) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xa}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0xa}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xa}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xa}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (LF) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xb}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0xb}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xb}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xb}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [3.2] (Newline) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x80}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xcc, 0x80}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xcc, 0x80}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] COMBINING GRAVE ACCENT (Extend) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xc2, 0xad}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xad}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xad}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] SOFT HYPHEN (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x93, 0x82}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xe2, 0x93, 0x82}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] CIRCLED LATIN CAPITAL LETTER M (ALetter_ExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x41}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x41}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x41}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x41}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x3a}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x3a}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x2c}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x2c}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x2e}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x2e}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x2e}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x2e}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x30}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x30}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x30}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x30}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x5f}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x5f}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x5f}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x5f}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xf0, 0x9f, 0x87, 0xa6}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xf0, 0x9f, 0x87, 0xa6}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xd7, 0x90}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xd7, 0x90}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xd7, 0x90}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x22}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x22}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x22}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x22}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x27}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x27}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xe2, 0x80, 0x8d}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xc2, 0xa9}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0xc2, 0xa9}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0xc2, 0xa9}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] COPYRIGHT SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x20}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x20}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x20}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x20}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x0}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x0}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x61, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x61, 0x3a}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x3a}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x61}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x61, 0x27}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x27}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x61}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x27, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x61}, {0x27, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] APOSTROPHE (Single_Quote) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x61, 0x2c}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0}, {0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x61, 0x2c}, expected: [][]byte{{0x31}, {0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88}, {0x61}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x31, 0x3a}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x3a}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31}, {0x3a}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x31, 0x27}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x27}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31}, {0x27}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x31, 0x2c}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x2c}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31}, {0x2c}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31, 0x2e, 0xe2, 0x81, 0xa0}, expected: [][]byte{{0x31, 0x2e, 0xe2, 0x81, 0xa0, 0xcc, 0x88, 0x31}, {0x2e, 0xe2, 0x81, 0xa0}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) × [4.0] COMBINING DIAERESIS (Extend) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format) ÷ [0.3]", }, { input: []byte{0xd, 0xa, 0x61, 0xa, 0xcc, 0x88}, expected: [][]byte{{0xd, 0xa}, {0x61}, {0xa}, {0xcc, 0x88}}, comment: "÷ [0.2] (CR) × [3.0] (LF) ÷ [3.1] LATIN SMALL LETTER A (ALettermExtPict) ÷ [3.2] (LF) ÷ [3.1] COMBINING DIAERESIS (Extend) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88}, expected: [][]byte{{0x61, 0xcc, 0x88}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) ÷ [0.3]", }, { input: []byte{0x20, 0xe2, 0x80, 0x8d, 0xd9, 0x86}, expected: [][]byte{{0x20, 0xe2, 0x80, 0x8d}, {0xd9, 0x86}}, comment: "÷ [0.2] SPACE (WSegSpace) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] ARABIC LETTER NOON (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xd9, 0x86, 0xe2, 0x80, 0x8d, 0x20}, expected: [][]byte{{0xd9, 0x86, 0xe2, 0x80, 0x8d}, {0x20}}, comment: "÷ [0.2] ARABIC LETTER NOON (ALettermExtPict) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]", }, { input: []byte{0xd9, 0xb1, 0xd9, 0x84, 0xd8, 0xb1, 0xd9, 0x8e, 0xd9, 0x91, 0xd8, 0xad, 0xd9, 0x90, 0xd9, 0x8a, 0xd9, 0x85, 0xd9, 0x90, 0x20, 0xdb, 0x9d, 0xd9, 0xa1}, expected: [][]byte{{0xd9, 0xb1, 0xd9, 0x84, 0xd8, 0xb1, 0xd9, 0x8e, 0xd9, 0x91, 0xd8, 0xad, 0xd9, 0x90, 0xd9, 0x8a, 0xd9, 0x85, 0xd9, 0x90}, {0x20}, {0xdb, 0x9d, 0xd9, 0xa1}}, comment: "÷ [0.2] ARABIC LETTER ALEF WASLA (ALettermExtPict) × [5.0] ARABIC LETTER LAM (ALettermExtPict) × [5.0] ARABIC LETTER REH (ALettermExtPict) × [4.0] ARABIC FATHA (Extend) × [4.0] ARABIC SHADDA (Extend) × [5.0] ARABIC LETTER HAH (ALettermExtPict) × [4.0] ARABIC KASRA (Extend) × [5.0] ARABIC LETTER YEH (ALettermExtPict) × [5.0] ARABIC LETTER MEEM (ALettermExtPict) × [4.0] ARABIC KASRA (Extend) ÷ [999.0] SPACE (WSegSpace) ÷ [999.0] ARABIC END OF AYAH (Numeric) × [8.0] ARABIC-INDIC DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0xdc, 0xa1, 0xdc, 0x99, 0xdc, 0xa1, 0xdc, 0x98, 0xdc, 0xaa, 0xdc, 0x90, 0x20, 0xdc, 0x8f, 0xdc, 0x9d, 0xdc, 0x97}, expected: [][]byte{{0xdc, 0xa1, 0xdc, 0x99, 0xdc, 0xa1, 0xdc, 0x98, 0xdc, 0xaa, 0xdc, 0x90}, {0x20}, {0xdc, 0x8f, 0xdc, 0x9d, 0xdc, 0x97}}, comment: "÷ [0.2] SYRIAC LETTER MIM (ALettermExtPict) × [5.0] SYRIAC LETTER ZAIN (ALettermExtPict) × [5.0] SYRIAC LETTER MIM (ALettermExtPict) × [5.0] SYRIAC LETTER WAW (ALettermExtPict) × [5.0] SYRIAC LETTER RISH (ALettermExtPict) × [5.0] SYRIAC LETTER ALAPH (ALettermExtPict) ÷ [999.0] SPACE (WSegSpace) ÷ [999.0] SYRIAC ABBREVIATION MARK (ALettermExtPict) × [5.0] SYRIAC LETTER YUDH (ALettermExtPict) × [5.0] SYRIAC LETTER HE (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xdc, 0xac, 0xdc, 0x8f, 0xdc, 0xab, 0xdc, 0x92, 0xdc, 0x98}, expected: [][]byte{{0xdc, 0xac, 0xdc, 0x8f, 0xdc, 0xab, 0xdc, 0x92, 0xdc, 0x98}}, comment: "÷ [0.2] SYRIAC LETTER TAW (ALettermExtPict) × [5.0] SYRIAC ABBREVIATION MARK (ALettermExtPict) × [5.0] SYRIAC LETTER SHIN (ALettermExtPict) × [5.0] SYRIAC LETTER BETH (ALettermExtPict) × [5.0] SYRIAC LETTER WAW (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0x41, 0x41}, expected: [][]byte{{0x41, 0x41, 0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) × [5.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0x3a, 0x41}, expected: [][]byte{{0x41, 0x3a, 0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [6.0] COLON (MidLetter) × [7.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x41, 0x3a, 0x3a, 0x41}, expected: [][]byte{{0x41}, {0x3a}, {0x3a}, {0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x27}, expected: [][]byte{{0xd7, 0x90, 0x27}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [7.1] APOSTROPHE (Single_Quote) ÷ [0.3]", }, { input: []byte{0xd7, 0x90, 0x22, 0xd7, 0x90}, expected: [][]byte{{0xd7, 0x90, 0x22, 0xd7, 0x90}}, comment: "÷ [0.2] HEBREW LETTER ALEF (Hebrew_Letter) × [7.2] QUOTATION MARK (Double_Quote) × [7.3] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]", }, { input: []byte{0x41, 0x30, 0x30, 0x41}, expected: [][]byte{{0x41, 0x30, 0x30, 0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [9.0] DIGIT ZERO (Numeric) × [8.0] DIGIT ZERO (Numeric) × [10.0] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x30, 0x2c, 0x30}, expected: [][]byte{{0x30, 0x2c, 0x30}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0x30, 0x2c, 0x2c, 0x30}, expected: [][]byte{{0x30}, {0x2c}, {0x2c}, {0x30}}, comment: "÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]", }, { input: []byte{0xe3, 0x80, 0xb1, 0xe3, 0x80, 0xb1}, expected: [][]byte{{0xe3, 0x80, 0xb1, 0xe3, 0x80, 0xb1}}, comment: "÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [13.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]", }, { input: []byte{0x41, 0x5f, 0x30, 0x5f, 0xe3, 0x80, 0xb1, 0x5f}, expected: [][]byte{{0x41, 0x5f, 0x30, 0x5f, 0xe3, 0x80, 0xb1, 0x5f}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ZERO (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] VERTICAL KANA REPEAT MARK (Katakana) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]", }, { input: []byte{0x41, 0x5f, 0x5f, 0x41}, expected: [][]byte{{0x41, 0x5f, 0x5f, 0x41}}, comment: "÷ [0.2] LATIN CAPITAL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN CAPITAL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8, 0x62}, expected: [][]byte{{0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7}, {0xf0, 0x9f, 0x87, 0xa8}, {0x62}}, comment: "÷ [0.2] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [15.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) ÷ [999.0] LATIN SMALL LETTER B (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8, 0x62}, expected: [][]byte{{0x61}, {0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7}, {0xf0, 0x9f, 0x87, 0xa8}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [16.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) ÷ [999.0] LATIN SMALL LETTER B (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x87, 0xa8, 0x62}, expected: [][]byte{{0x61}, {0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xe2, 0x80, 0x8d}, {0xf0, 0x9f, 0x87, 0xa8}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [16.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) ÷ [999.0] LATIN SMALL LETTER B (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8, 0x62}, expected: [][]byte{{0x61}, {0xf0, 0x9f, 0x87, 0xa6, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x87, 0xa7}, {0xf0, 0x9f, 0x87, 0xa8}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [4.0] ZERO WIDTH JOINER (ZWJ) × [16.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) ÷ [999.0] LATIN SMALL LETTER B (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7, 0xf0, 0x9f, 0x87, 0xa8, 0xf0, 0x9f, 0x87, 0xa9, 0x62}, expected: [][]byte{{0x61}, {0xf0, 0x9f, 0x87, 0xa6, 0xf0, 0x9f, 0x87, 0xa7}, {0xf0, 0x9f, 0x87, 0xa8, 0xf0, 0x9f, 0x87, 0xa9}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) × [16.0] REGIONAL INDICATOR SYMBOL LETTER B (RI) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER C (RI) × [16.0] REGIONAL INDICATOR SYMBOL LETTER D (RI) ÷ [999.0] LATIN SMALL LETTER B (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf, 0xf0, 0x9f, 0x91, 0xb6}, expected: [][]byte{{0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf}, {0xf0, 0x9f, 0x91, 0xb6}}, comment: "÷ [0.2] BABY (ExtPictmALetter) × [4.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend) ÷ [999.0] BABY (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x9b, 0x91, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}, expected: [][]byte{{0xf0, 0x9f, 0x9b, 0x91, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}}, comment: "÷ [0.2] OCTAGONAL SIGN (ExtPictmALetter) × [4.0] ZERO WIDTH JOINER (ZWJ) × [3.3] OCTAGONAL SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}, expected: [][]byte{{0x61, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] ZERO WIDTH JOINER (ZWJ) × [3.3] OCTAGONAL SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x9c, 0x81, 0xe2, 0x80, 0x8d, 0xe2, 0x9c, 0x81}, expected: [][]byte{{0xe2, 0x9c, 0x81, 0xe2, 0x80, 0x8d}, {0xe2, 0x9c, 0x81}}, comment: "÷ [0.2] UPPER BLADE SCISSORS (XXmExtPict) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] UPPER BLADE SCISSORS (XXmExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0xe2, 0x80, 0x8d, 0xe2, 0x9c, 0x81}, expected: [][]byte{{0x61, 0xe2, 0x80, 0x8d}, {0xe2, 0x9c, 0x81}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] ZERO WIDTH JOINER (ZWJ) ÷ [999.0] UPPER BLADE SCISSORS (XXmExtPict) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf, 0xcc, 0x88, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf}, expected: [][]byte{{0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf, 0xcc, 0x88, 0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x91, 0xb6, 0xf0, 0x9f, 0x8f, 0xbf}}, comment: "÷ [0.2] BABY (ExtPictmALetter) × [4.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) × [3.3] BABY (ExtPictmALetter) × [4.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x9b, 0x91, 0xf0, 0x9f, 0x8f, 0xbf}, expected: [][]byte{{0xf0, 0x9f, 0x9b, 0x91, 0xf0, 0x9f, 0x8f, 0xbf}}, comment: "÷ [0.2] OCTAGONAL SIGN (ExtPictmALetter) × [4.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91, 0xf0, 0x9f, 0x8f, 0xbf}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91, 0xf0, 0x9f, 0x8f, 0xbf}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [3.3] OCTAGONAL SIGN (ExtPictmALetter) × [4.0] EMOJI MODIFIER FITZPATRICK TYPE-6 (Extend) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [3.3] OCTAGONAL SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}, expected: [][]byte{{0xe2, 0x80, 0x8d, 0xf0, 0x9f, 0x9b, 0x91}}, comment: "÷ [0.2] ZERO WIDTH JOINER (ZWJ) × [3.3] OCTAGONAL SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0xf0, 0x9f, 0x9b, 0x91, 0xf0, 0x9f, 0x9b, 0x91}, expected: [][]byte{{0xf0, 0x9f, 0x9b, 0x91}, {0xf0, 0x9f, 0x9b, 0x91}}, comment: "÷ [0.2] OCTAGONAL SIGN (ExtPictmALetter) ÷ [999.0] OCTAGONAL SIGN (ExtPictmALetter) ÷ [0.3]", }, { input: []byte{0x61, 0xcc, 0x88, 0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x62}, expected: [][]byte{{0x61, 0xcc, 0x88, 0xe2, 0x80, 0x8d, 0xcc, 0x88, 0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [4.0] COMBINING DIAERESIS (Extend) × [4.0] ZERO WIDTH JOINER (ZWJ) × [4.0] COMBINING DIAERESIS (Extend) × [5.0] LATIN SMALL LETTER B (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x20, 0x20, 0x62}, expected: [][]byte{{0x61}, {0x20, 0x20}, {0x62}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] SPACE (WSegSpace) × [3.4] SPACE (WSegSpace) ÷ [999.0] LATIN SMALL LETTER B (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x3a, 0x31}, expected: [][]byte{{0x31}, {0x3a}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x3a, 0x3a, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x3a}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x3a, 0x3a, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x3a}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x3a, 0x61}, expected: [][]byte{{0x31}, {0x3a}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x3a, 0x3a, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x3a}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x3a, 0x3a, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x3a}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x2e, 0x31}, expected: [][]byte{{0x31}, {0x3a}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x3a, 0x2e, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x3a}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x3a, 0x2e, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x3a}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x2e, 0x61}, expected: [][]byte{{0x31}, {0x3a}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x3a, 0x2e, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x3a}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x3a, 0x2e, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x3a}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x2c, 0x31}, expected: [][]byte{{0x31}, {0x3a}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x3a, 0x2c, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x3a}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x3a, 0x2c, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x3a}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x3a, 0x2c, 0x61}, expected: [][]byte{{0x31}, {0x3a}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x3a, 0x2c, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x3a}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x3a, 0x2c, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x3a}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0x3a, 0x31}, expected: [][]byte{{0x31}, {0x2e}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2e, 0x3a, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2e}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2e, 0x3a, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2e}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0x3a, 0x61}, expected: [][]byte{{0x31}, {0x2e}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2e, 0x3a, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2e}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2e, 0x3a, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2e}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0x2e, 0x31}, expected: [][]byte{{0x31}, {0x2e}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2e, 0x2e, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2e}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2e, 0x2e, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2e}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0x2e, 0x61}, expected: [][]byte{{0x31}, {0x2e}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2e, 0x2e, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2e}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2e, 0x2e, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2e}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0x2c, 0x31}, expected: [][]byte{{0x31}, {0x2e}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2e, 0x2c, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2e}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2e, 0x2c, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2e}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2e, 0x2c, 0x61}, expected: [][]byte{{0x31}, {0x2e}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2e, 0x2c, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2e}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2e, 0x2c, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2e}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x3a, 0x31}, expected: [][]byte{{0x31}, {0x2c}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2c, 0x3a, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2c}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2c, 0x3a, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2c}, {0x3a}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x3a, 0x61}, expected: [][]byte{{0x31}, {0x2c}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2c, 0x3a, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2c}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2c, 0x3a, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2c}, {0x3a}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x2e, 0x31}, expected: [][]byte{{0x31}, {0x2c}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2c, 0x2e, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2c}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2c, 0x2e, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2c}, {0x2e}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x2e, 0x61}, expected: [][]byte{{0x31}, {0x2c}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2c, 0x2e, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2c}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2c, 0x2e, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2c}, {0x2e}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x2c, 0x31}, expected: [][]byte{{0x31}, {0x2c}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2c, 0x2c, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2c}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2c, 0x2c, 0x31}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2c}, {0x2c}, {0x31}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x31, 0x2c, 0x2c, 0x61}, expected: [][]byte{{0x31}, {0x2c}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x31, 0x2c, 0x2c, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x31}, {0x2c}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x31, 0x5f, 0x61, 0x2c, 0x2c, 0x61}, expected: [][]byte{{0x31, 0x5f, 0x61}, {0x2c}, {0x2c}, {0x61}}, comment: "÷ [0.2] DIGIT ONE (Numeric) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x3a, 0x31}, expected: [][]byte{{0x61}, {0x3a}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x3a, 0x3a, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x3a}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x3a, 0x3a, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x3a}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x3a, 0x61}, expected: [][]byte{{0x61}, {0x3a}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x3a, 0x3a, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x3a}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x3a, 0x3a, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x3a}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x2e, 0x31}, expected: [][]byte{{0x61}, {0x3a}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x3a, 0x2e, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x3a}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x3a, 0x2e, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x3a}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x2e, 0x61}, expected: [][]byte{{0x61}, {0x3a}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x3a, 0x2e, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x3a}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x3a, 0x2e, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x3a}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x2c, 0x31}, expected: [][]byte{{0x61}, {0x3a}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x3a, 0x2c, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x3a}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x3a, 0x2c, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x3a}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x3a, 0x2c, 0x61}, expected: [][]byte{{0x61}, {0x3a}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x3a, 0x2c, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x3a}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x3a, 0x2c, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x3a}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0x3a, 0x31}, expected: [][]byte{{0x61}, {0x2e}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2e, 0x3a, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2e}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2e, 0x3a, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2e}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0x3a, 0x61}, expected: [][]byte{{0x61}, {0x2e}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2e, 0x3a, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2e}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2e, 0x3a, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2e}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0x2e, 0x31}, expected: [][]byte{{0x61}, {0x2e}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2e, 0x2e, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2e}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2e, 0x2e, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2e}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0x2e, 0x61}, expected: [][]byte{{0x61}, {0x2e}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2e, 0x2e, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2e}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2e, 0x2e, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2e}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0x2c, 0x31}, expected: [][]byte{{0x61}, {0x2e}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2e, 0x2c, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2e}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2e, 0x2c, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2e}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2e, 0x2c, 0x61}, expected: [][]byte{{0x61}, {0x2e}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2e, 0x2c, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2e}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2e, 0x2c, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2e}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x3a, 0x31}, expected: [][]byte{{0x61}, {0x2c}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2c, 0x3a, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2c}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2c, 0x3a, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2c}, {0x3a}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x3a, 0x61}, expected: [][]byte{{0x61}, {0x2c}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2c, 0x3a, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2c}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2c, 0x3a, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2c}, {0x3a}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x2e, 0x31}, expected: [][]byte{{0x61}, {0x2c}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2c, 0x2e, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2c}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2c, 0x2e, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2c}, {0x2e}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x2e, 0x61}, expected: [][]byte{{0x61}, {0x2c}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2c, 0x2e, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2c}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2c, 0x2e, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2c}, {0x2e}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] FULL STOP (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x2c, 0x31}, expected: [][]byte{{0x61}, {0x2c}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2c, 0x2c, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2c}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2c, 0x2c, 0x31}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2c}, {0x2c}, {0x31}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [0.3]", }, { input: []byte{0x61, 0x2c, 0x2c, 0x61}, expected: [][]byte{{0x61}, {0x2c}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x31, 0x2c, 0x2c, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x31}, {0x2c}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, { input: []byte{0x61, 0x5f, 0x61, 0x2c, 0x2c, 0x61}, expected: [][]byte{{0x61, 0x5f, 0x61}, {0x2c}, {0x2c}, {0x61}}, comment: "÷ [0.2] LATIN SMALL LETTER A (ALettermExtPict) × [13.1] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALettermExtPict) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALettermExtPict) ÷ [0.3]", }, }