From c4538d4c6c287f121b89b5d90c7443e1f817314f Mon Sep 17 00:00:00 2001 From: Ian Flanigan Date: Sun, 18 Oct 2020 21:16:19 +0200 Subject: [PATCH 1/2] Create performance tests for CPU implementations This creates a very simple test harness for CPU implementations that can be run in the browser. It is not dependent on any other libraries. The harness supports a number of warmup runs and a number of timing runs. It records the min, max, mean, and median times for the test runs. This works by creating a new entrypoint, `cpu_benchmark`, which is loaded by the `test/perf/cpu_benchmark.html` file. You can fire up a Node server to serve this by running: ```shell node http-server ./ ``` This change also adds the `bin2js` utility that can create JS files out of binary ROM images. --- bin/bin2js | 91 + test/perf/cpu_benchmark.html | 80 + test/perf/cpu_benchmark.js | 225 + test/perf/impl/jscpu6502.js | 1633 +++++++ test/perf/impl/tscpu6502.ts | 1759 +++++++ test/perf/impl/tscpu6502v2.ts | 1772 +++++++ test/perf/impl/tscpu6502v5.ts | 1979 ++++++++ test/perf/test6502rom.js | 8215 +++++++++++++++++++++++++++++++++ test/perf/test65c02rom.js | 8215 +++++++++++++++++++++++++++++++++ test/tscpu6502.spec.js | 2240 +++++++++ test/tscpu6502v2.spec.js | 2240 +++++++++ test/tscpu6502v5.spec.js | 2240 +++++++++ webpack.config.js | 3 +- 13 files changed, 30691 insertions(+), 1 deletion(-) create mode 100755 bin/bin2js create mode 100644 test/perf/cpu_benchmark.html create mode 100644 test/perf/cpu_benchmark.js create mode 100644 test/perf/impl/jscpu6502.js create mode 100644 test/perf/impl/tscpu6502.ts create mode 100644 test/perf/impl/tscpu6502v2.ts create mode 100644 test/perf/impl/tscpu6502v5.ts create mode 100644 test/perf/test6502rom.js create mode 100644 test/perf/test65c02rom.js create mode 100644 test/tscpu6502.spec.js create mode 100644 test/tscpu6502v2.spec.js create mode 100644 test/tscpu6502v5.spec.js diff --git a/bin/bin2js b/bin/bin2js new file mode 100755 index 00000000..b9ceac9b --- /dev/null +++ b/bin/bin2js @@ -0,0 +1,91 @@ +#!/usr/bin/env node + +const { exit } = require('process'); + +const readFile = require('fs').promises.readFile; +const argv = require('yargs').argv; + +const fileName = argv._[0]; +const name = argv.n || argv.name; +const start = argv.s !== undefined ? argv.s : argv.start; + +function toHex(v, n) { + if (!n) { + n = 2 + } + let r = v.toString(16); + r = r.padStart(n, '0'); + return r; +} + +function usage(message) { + if (message) { + console.error(message); + } + console.error("bin2js -n name -s start binfile"); +} + +if (argv.h || argv.help) { + usage(); + process.exit(0); +} +if (!name || !fileName || (typeof name != "string")) { + usage("must specify a file name for binfile"); + process.exit(1); +} + +if (start === "" || start === undefined) { + usage("must specify a start page"); + process.exit(2); +} + +if (typeof start === "string") { + if (start.startsWith("0x")) { + start = parseInt(start.slice(2), 16); + } else { + start = parseInt(start, 10); + } +} + +readFile(fileName, { flag: 'r' }).then((fileData => { + if (fileData.length % 256 != 0) { + console.error(`${filename} length is not a multiple of 256`); + process.exit(2); + } + let end = start + fileData.length / 256 - 1; + console.log('const MEMORY = ['); + const step = 0x08; + for (let i = 0; i < fileData.length; i += step) { + let line = ' '; + for (let j = i; j < fileData.length && j < i + step; j++) { + line += '0x' + toHex(fileData[j]) + ', '; + } + line += '// ' + toHex(i, 4); + console.log(line); + } + console.log('];'); + console.log(); + console.log(`export default function ${name}() {`); + console.log(' let mem = [...MEMORY];'); + console.log(' return {'); + console.log(' start: function() {'); + console.log(` return 0x${toHex(start)};`); + console.log(' },'); + console.log(' end: function() {'); + console.log(` return 0x${toHex(end)};`); + console.log(' },'); + console.log(' read: function(page, off) {'); + console.log(` return mem[(page - 0x${toHex(start)}) << 8 | off];`); + console.log(' },'); + console.log(' write: function(page, off, val) {'); + console.log(` mem[(page - 0x${toHex(start)}) << 8 | off] = val;`); + console.log(' },'); + console.log(' reset: function() {'); + console.log(' mem = [...MEMORY];'); + console.log(' },'); + console.log(' };'); + console.log('}'); +})).catch((reason) => { + console.error('Unable to read binary file:', reason); + process.exit(1); +}); diff --git a/test/perf/cpu_benchmark.html b/test/perf/cpu_benchmark.html new file mode 100644 index 00000000..1e267189 --- /dev/null +++ b/test/perf/cpu_benchmark.html @@ -0,0 +1,80 @@ + + + + + Benchmark for 6502 + + + + + + +

Benchmark for 6502

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
cpu6502.js
650265C02
min
max
mean
median
runs
+ + + \ No newline at end of file diff --git a/test/perf/cpu_benchmark.js b/test/perf/cpu_benchmark.js new file mode 100644 index 00000000..b7b88706 --- /dev/null +++ b/test/perf/cpu_benchmark.js @@ -0,0 +1,225 @@ +import JSCPU6502 from './impl/jscpu6502'; +import TSCPU6502 from './impl/tscpu6502'; +import TSCPU6502v2 from './impl/tscpu6502v2'; +import TSCPU6502v5 from './impl/tscpu6502v5'; +import Test6502 from './test6502rom'; +import Test65C02 from './test65c02rom'; + +let cpu; +let memory; +let done; +let lastPC; +let callbacks = 0; + +function traceCB() { + let pc = cpu.getPC(); + done = (lastPC == pc) || (pc < 0x100); + lastPC = pc; + callbacks++; +} + +function setup6502(cpuType) { + cpu = new cpuType(); + memory = new Test6502(); + cpu.addPageHandler(memory); +} + +function setup65C02(cpuType) { + cpu = new cpuType({ '65C02': true }); + memory = new Test65C02(); + cpu.addPageHandler(memory); +} + +function runCPU(stopPC, maxCallbacks) { + done = false; + lastPC = 0x0000; + callbacks = 0; + cpu.reset(); + memory.reset(); + cpu.setPC(0x400); + + do { + cpu.stepCyclesDebug(1000, traceCB); + } while (!done && callbacks <= maxCallbacks); + if (cpu.getPC() < 0x100) { + console.log('PC in zero page'); + } + if (cpu.getPC() != stopPC) { + console.log(`stop PC incorrect: ${cpu.getPC().toString(16)} != ${stopPC.toString(16)}`); + } + if (callbacks > maxCallbacks) { + console.log('too many callbacks'); + } +} + +const tests = [ + { + impl: 'cpu6502.js', + emul: '6502', + setup: () => setup6502(JSCPU6502), + test: () => runCPU(0x3469, 30648245), + }, + { + impl: 'cpu6502.js', + emul: '65C02', + setup: () => setup65C02(JSCPU6502), + test: () => runCPU(0x24f1, 21987280), + }, + { + impl: 'cpu6502.ts', + emul: '6502', + setup: () => setup6502(TSCPU6502), + test: () => runCPU(0x3469, 30648245), + }, + { + impl: 'cpu6502.ts', + emul: '65C02', + setup: () => setup65C02(TSCPU6502), + test: () => runCPU(0x24f1, 21987280), + }, + { + impl: 'cpu6502v2.ts', + emul: '6502', + setup: () => setup6502(TSCPU6502v2), + test: () => runCPU(0x3469, 30648245), + }, + { + impl: 'cpu6502v2.ts', + emul: '65C02', + setup: () => setup65C02(TSCPU6502v2), + test: () => runCPU(0x24f1, 21987280), + }, + { + impl: 'cpu6502v5.ts', + emul: '6502', + setup: () => setup6502(TSCPU6502v5), + test: () => runCPU(0x3469, 30648245), + }, + // { + // id: 'tsv5_65C02', + // setup: () => setup65C02(TSCPU6502v5), + // test: () => runCPU(0x24f1, 21987280), + // }, +]; + +const IMPLS = [...new Set(tests.map((e) => e.impl))]; + + +const RUNS = 50; +const WARMUP = 10; + +function pause() { + return new Promise(resolve => setTimeout(resolve, 0)); +} + +function round(x, n) { + return Math.round(x * Math.pow(10, n)) / Math.pow(10, n); +} + +function shuffle(/** @type Array<*> */ a) { + for (let i = a.length - 1; i > 1; i--) { + let j = Math.floor(Math.random() * (i + 1)); + if (j !== i) { + let t = a[i]; + a[i] = a[j]; + a[j] = t; + } + } +} + +function ensureSibling( + /** @type Element */ e, + /** @type function(): Element */ f) { + if (!e.nextElementSibling) { + e.parentElement.appendChild(f()); + } + return e.nextElementSibling; +} + +function clearSiblings(/** @type Element */ e) { + while (e.nextElementSibling) { + e.parentElement.removeChild(e.nextElementSibling); + } +} + +function expandTable( + /** @type Element */ e, + /** @type string */ name, + /** @type number */ i) { + e = ensureSibling(e, () => document.createElement("td")); + e.setAttribute("id", name + "_" + i + "_6502"); + e = ensureSibling(e, () => document.createElement("td")); + e.setAttribute("id", name + "_" + i + "_65C02"); + return e; +} + +function buildTable() { + let table = document.getElementById("benchmarks"); + let implElement = document.getElementById("impl").firstElementChild; + let emulElement = document.getElementById("emul").firstElementChild; + let minElement = document.getElementById("min").firstElementChild; + let maxElement = document.getElementById("max").firstElementChild; + let meanElement = document.getElementById("mean").firstElementChild; + let medianElement = document.getElementById("median").firstElementChild; + let runsElement = document.getElementById("runs").firstElementChild; + + for (let i = 0; i < IMPLS.length; i++) { + let impl = IMPLS[i]; + implElement = ensureSibling(implElement, () => document.createElement("th")); + implElement.setAttribute("colspan", "2"); + implElement.innerText = impl; + + emulElement = ensureSibling(emulElement, () => document.createElement("th")); + emulElement.innerText = "6502"; + emulElement = ensureSibling(emulElement, () => document.createElement("th")); + emulElement.innerText = "65C02"; + + minElement = expandTable(minElement, "min", i); + maxElement = expandTable(maxElement, "max", i); + meanElement = expandTable(meanElement, "mean", i); + medianElement = expandTable(medianElement, "median", i); + runsElement = expandTable(runsElement, "runs", i); + } + clearSiblings(implElement); +} + +function name(test) { + return test.impl + " " + test.emul; +} + +export async function benchmark() { + console.log('benchmark'); + buildTable(); + console.log('table built'); + await pause(); + let stats = {}; + for (let i = 0; i < tests.length; i++) { + console.log('setting up', name(tests[i])); + tests[i].setup(); + console.log('starting warmup of', name(tests[i])); + for (let w = 0; w < WARMUP; w++) { + tests[i].test(); + await pause(); + } + console.log('running ', name(tests[i])); + let runs = []; + for (let r = 0; r < RUNS; r++) { + let start = performance.now(); + tests[i].test(); + let end = performance.now(); + let delta = round(end - start, 2); + runs.push(delta); + runs.sort((a, b) => a - b); + let id = IMPLS.indexOf(tests[i].impl) + "_" + tests[i].emul; + document.getElementById('min_' + id).innerText = runs[0]; + document.getElementById('max_' + id).innerText = runs[runs.length - 1]; + document.getElementById('median_' + id).innerText = runs[Math.floor(runs.length / 2)]; + document.getElementById('mean_' + id).innerText = round(runs.reduce((a, b) => (a + b)) / runs.length, 2); + document.getElementById('runs_' + id).innerText = runs.length; + await pause(); + } + console.log(`${name(tests[i])} runs = `, runs); + } +} + +window.benchmark = benchmark; diff --git a/test/perf/impl/jscpu6502.js b/test/perf/impl/jscpu6502.js new file mode 100644 index 00000000..10eb6f7a --- /dev/null +++ b/test/perf/impl/jscpu6502.js @@ -0,0 +1,1633 @@ +/* + * Copyright 2010-2019 Will Scullin + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +import { debug, toHex } from '../../../js/util'; + +export default function JSCPU6502(options) +{ + options = options || {}; + + var is65C02 = options['65C02'] ? true : false; + + /* Registers */ + var pc = 0, // Program Counter + sr = 0x20, // Process Status Register + ar = 0, // Accumulator + xr = 0, // X Register + yr = 0, // Y Register + sp = 0xff; // Stack Pointer + + /* Addressing Mode */ + var modes = { + accumulator: 0, // A (Accumulator) + implied: 1, // Implied + immediate: 2, // # Immediate + absolute: 3, // a Absolute + zeroPage: 4, // zp Zero Page + relative: 5, // r Relative + + absoluteX: 6, // a,X Absolute, X + absoluteY: 7, // a,Y Absolute, Y + zeroPageX: 8, // zp,X Zero Page, X + zeroPageY: 9, // zp,Y Zero Page, Y + + absoluteIndirect: 10, // (a) Indirect + zeroPageXIndirect: 11, // (zp,X) Zero Page Indexed Indirect + zeroPageIndirectY: 12, // (zp),Y Zero Page Indexed with Y + + /* 65c02 */ + zeroPageIndirect: 13, // (zp), + absoluteXIndirect: 14, // (a, X), + zeroPage_relative: 15 // zp, Relative + }; + + var sizes = { + 0 /* modes.accumulator */: 1, + 1 /* modes.implied */: 1, + 2 /* modes.immediate */: 2, + 3 /* modes.absolute */: 3, + 4 /* modes.zeroPage */: 2, + 5 /* modes.relative */: 2, + 6 /* modes.absoluteX */: 3, + 7 /* modes.absoluteY */: 3, + 8 /* modes.zeroPageX */: 2, + 9 /* modes.zeroPageY */: 2, + 10 /* modes.indirect */: 3, + 11 /* modes.zeroPageXIndirect */: 2, + 12 /* modes.zeroPageYIndirect */: 2, + + 13 /* mode.zeroPageIndirect */: 2, + 14 /* mode.absoluteXIndirect */: 3, + 15 /* mode.zeroPage_relative */: 3 + }; + + /* Flags */ + var flags = { + N: 0x80, // Negative + V: 0x40, // oVerflow + B: 0x10, // Break + D: 0x08, // Decimal + I: 0x04, // Interrupt + Z: 0x02, // Zero + C: 0x01 // Carry + }; + + /* Memory Locations */ + var loc = { + STACK: 0x100, + NMI: 0xFFFA, + RESET: 0xFFFC, + BRK: 0xFFFE + }; + + var idx; + + var readPages = []; + var writePages = []; + var resetHandlers = []; + var cycles = 0; + var sync = false; + + var blankPage = { + read: function() { return 0; }, + write: function() {} + }; + + for (idx = 0; idx < 0x100; idx++) { + readPages[idx] = blankPage; + writePages[idx] = blankPage; + } + + function setFlag(f, on) { + sr = on ? (sr | f) : (sr & ~f); + } + + function testNZ(val) { + sr = val === 0 ? (sr | flags.Z) : (sr & ~flags.Z); + sr = (val & 0x80) ? (sr | flags.N) : (sr & ~flags.N); + + return val; + } + + function testZ(val) { + sr = val === 0 ? (sr | flags.Z) : (sr & ~flags.Z); + + return val; + } + + function add(a, b, sub) { + if (sub) + b ^= 0xff; + + // KEGS + var c, v; + if ((sr & flags.D) !== 0) { + c = (a & 0x0f) + (b & 0x0f) + (sr & flags.C); + if (sub) { + if (c < 0x10) + c = (c - 0x06) & 0x0f; + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c < 0x100) + c = (c + 0xa0) & 0xff; + } else { + if (c > 0x09) + c = (c - 0x0a) | 0x10; // carry to MSN + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c > 0x99) + c += 0x60; + } + } else { + c = a + b + (sr & flags.C); + v = (c ^ a) & 0x80; + } + + if (((a ^ b) & 0x80) !== 0) { + v = 0; + } + + setFlag(flags.C, c > 0xff); + setFlag(flags.V, v); + + return testNZ(c & 0xff); + } + + function increment(a) { + return testNZ((a + 0x01) & 0xff); + } + + function decrement(a) { + return testNZ((a + 0xff) & 0xff); + } + + function readBytePC() { + var addr = pc, + page = addr >> 8, + off = addr & 0xff; + + var result = readPages[page].read(page, off); + + pc = (pc + 1) & 0xffff; + + cycles++; + + return result; + } + + function readByte(addr) { + var page = addr >> 8, + off = addr & 0xff; + + var result = readPages[page].read(page, off); + + cycles++; + + return result; + } + + function readByteDebug(addr) { + var page = addr >> 8, + off = addr & 0xff; + + return readPages[page].read(page, off); + } + + function writeByte(addr, val) { + var page = addr >> 8, + off = addr & 0xff; + + writePages[page].write(page, off, val); + + cycles++; + } + + function readWord(addr) { + return readByte(addr) | (readByte(addr + 1) << 8); + } + + function readWordDebug(addr) { + return readByteDebug(addr) | (readByteDebug(addr + 1) << 8); + } + + function readWordPC() { + return readBytePC() | (readBytePC() << 8); + } + + function readZPWord(addr) { + var lsb, msb; + + lsb = readByte(addr & 0xff); + msb = readByte((addr + 1) & 0xff); + + return (msb << 8) | lsb; + } + + function pushByte(val) { + writeByte(loc.STACK | sp, val); + sp = (sp + 0xff) & 0xff; + } + + function pushWord(val) { + pushByte(val >> 8); + pushByte(val & 0xff); + } + + function pullByte() { + sp = (sp + 0x01) & 0xff; + return readByte(loc.STACK | sp); + } + + function pullWordRaw() { + var lsb = pullByte(loc.STACK | sp); + var msb = pullByte(loc.STACK | sp); + + return (msb << 8) | lsb; + } + + /* + * Read functions + */ + + function readImplied() { + } + + // #$00 + function readImmediate() { + return readBytePC(); + } + + // $0000 + function readAbsolute() { + return readByte(readWordPC()); + } + + // $00 + function readZeroPage() { + return readByte(readBytePC()); + } + + // $0000,X + function readAbsoluteX() { + var addr = readWordPC(); + var oldPage = addr >> 8; + addr = (addr + xr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + readByte(oldPage << 8 | off); + } + return readByte(addr); + } + + // $0000,Y + function readAbsoluteY() { + var addr = readWordPC(); + var oldPage = addr >> 8; + addr = (addr + yr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + readByte(oldPage << 8 | off); + } + return readByte(addr); + } + + // $00,X + function readZeroPageX() { + var zpAddr = readBytePC(); + readByte(zpAddr); + return readByte((zpAddr + xr) & 0xff); + } + + // $00,Y + function readZeroPageY() { + var zpAddr = readBytePC(); + readByte(zpAddr); + return readByte((zpAddr + yr) & 0xff); + } + + // ($00,X) + function readZeroPageXIndirect() { + var zpAddr = readBytePC(); + readByte(zpAddr); + var addr = readZPWord((zpAddr + xr) & 0xff); + return readByte(addr); + } + + // ($00),Y + function readZeroPageIndirectY() { + var addr = readZPWord(readBytePC()); + var oldPage = addr >> 8; + addr = (addr + yr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + readByte(oldPage << 8 | off); + } + return readByte(addr); + } + + // ($00) (65C02) + function readZeroPageIndirect() { + return readByte(readZPWord(readBytePC())); + } + + /* + * Write Functions + */ + + // $0000 + function writeAbsolute(val) { + writeByte(readWordPC(), val); + } + + // $00 + function writeZeroPage(val) { + writeByte(readBytePC(), val); + } + + // $0000,X + function writeAbsoluteX(val) { + var addr = readWordPC(), oldPage = addr >> 8; + addr = (addr + xr) & 0xffff; + var off = addr & 0xff; + readByte(oldPage << 8 | off); + writeByte(addr, val); + } + + // $0000,Y + function writeAbsoluteY(val) { + var addr = readWordPC(), oldPage = addr >> 8; + addr = (addr + yr) & 0xffff; + var off = addr & 0xff; + readByte(oldPage << 8 | off); + writeByte(addr, val); + } + + // $00,X + function writeZeroPageX(val) { + var zpAddr = readBytePC(); + readByte(zpAddr); + writeByte((zpAddr + xr) & 0xff, val); + } + + // $00,Y + function writeZeroPageY(val) { + var zpAddr = readBytePC(); + readByte(zpAddr); + writeByte((zpAddr + yr) & 0xff, val); + } + + // ($00,X) + function writeZeroPageXIndirect(val) { + var zpAddr = readBytePC(); + readByte(zpAddr); + var addr = readZPWord((zpAddr + xr) & 0xff); + writeByte(addr, val); + } + + // ($00),Y + function writeZeroPageIndirectY(val) { + var addr = readZPWord(readBytePC()), oldPage = addr >> 8; + addr = (addr + yr) & 0xffff; + var off = addr & 0xff; + readByte(oldPage << 8 | off); + writeByte(addr, val); + } + + // ($00) (65C02) + function writeZeroPageIndirect(val) { + writeByte(readZPWord(readBytePC()), val); + } + + // $00 + function readAddrZeroPage() { + return readBytePC(); + } + + // $00,X + function readAddrZeroPageX() { + var zpAddr = readBytePC(); + readByte(zpAddr); + return (zpAddr + xr) & 0xff; + } + + // $0000 (65C02) + function readAddrAbsolute() { + return readWordPC(); + } + + // ($0000) (6502) + function readAddrAbsoluteIndirectBug() { + var addr = readWordPC(); + var page = addr & 0xff00; + var off = addr & 0x00ff; + var lsb = readByte(addr); + var msb = readByte(page | ((off + 0x01) & 0xff)); + return msb << 8 | lsb; + } + + // ($0000) (65C02) + function readAddrAbsoluteIndirect() { + var lsb = readBytePC(); + var msb = readBytePC(); + readByte(pc); + return readWord(msb << 8 | lsb); + } + + // $0000,X + function readAddrAbsoluteX(opts) { + var addr = readWordPC(); + if (!is65C02 || (opts && opts.rwm)) { + readByte(addr); + } else { + readByte(pc); + } + return (addr + xr) & 0xffff; + } + + // $(0000,X) (65C02) + function readAddrAbsoluteXIndirect() { + var address = readWordPC(); + readByte(pc); + return readWord((address + xr) & 0xffff); + } + + /* Break */ + function brk(readFn) { + readFn(); + pushWord(pc); + pushByte(sr | flags.B); + if (is65C02) { + setFlag(flags.D, false); + } + setFlag(flags.I, true); + pc = readWord(loc.BRK); + } + + /* Load Accumulator */ + function lda(readFn) { + ar = testNZ(readFn()); + } + + /* Load X Register */ + function ldx(readFn) { + xr = testNZ(readFn()); + } + + /* Load Y Register */ + function ldy(readFn) { + yr = testNZ(readFn()); + } + + /* Store Accumulator */ + function sta(writeFn) { + writeFn(ar); + } + + /* Store X Register */ + function stx(writeFn) { + writeFn(xr); + } + + /* Store Y Register */ + function sty(writeFn) { + writeFn(yr); + } + + /* Store Zero */ + function stz(writeFn) { + writeFn(0); + } + + /* Add with Carry */ + function adc(readFn) { + ar = add(ar, readFn(), false); + } + + /* Subtract with Carry */ + function sbc(readFn) { + ar = add(ar, readFn(), true); + } + + /* Increment Memory */ + function incA() { + readByte(pc); + ar = increment(ar); + } + + function inc(readAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = readByte(addr); + writeByte(addr, oldVal); + var val = increment(oldVal); + writeByte(addr, val); + } + + /* Increment X */ + function inx() { + readByte(pc); + xr = increment(xr); + } + + /* Increment Y */ + function iny() { + readByte(pc); + yr = increment(yr); + } + + /* Decrement Memory */ + function decA() { + readByte(pc); + ar = decrement(ar); + } + + function dec(readAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = readByte(addr); + writeByte(addr, oldVal); + var val = decrement(oldVal); + writeByte(addr, val); + } + + /* Decrement X */ + function dex() { + readByte(pc); + xr = decrement(xr); + } + + /* Decrement Y */ + function dey() { + readByte(pc); + yr = decrement(yr); + } + + function shiftLeft(val) { + setFlag(flags.C, val & 0x80); + return testNZ((val << 1) & 0xff); + } + + /* Arithmetic Shift Left */ + function aslA() { + readByte(pc); + ar = shiftLeft(ar); + } + + function asl(readAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = readByte(addr); + writeByte(addr, oldVal); + var val = shiftLeft(oldVal); + writeByte(addr, val); + } + + function shiftRight(val) { + setFlag(flags.C, val & 0x01); + return testNZ(val >> 1); + } + + /* Logical Shift Right */ + function lsrA() { + readByte(pc); + ar = shiftRight(ar); + } + + function lsr(readAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = readByte(addr); + writeByte(addr, oldVal); + var val = shiftRight(oldVal); + writeByte(addr, val); + } + + function rotateLeft(val) { + var c = (sr & flags.C); + setFlag(flags.C, val & 0x80); + return testNZ(((val << 1) | (c ? 0x01 : 0x00)) & 0xff); + } + + /* Rotate Left */ + function rolA() { + readByte(pc); + ar = rotateLeft(ar); + } + + function rol(readAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = readByte(addr); + writeByte(addr, oldVal); + var val = rotateLeft(oldVal); + writeByte(addr, val); + } + + function rotateRight(a) { + var c = (sr & flags.C); + setFlag(flags.C, a & 0x01); + return testNZ((a >> 1) | (c ? 0x80 : 0x00)); + } + + /* Rotate Right */ + function rorA() { + readByte(pc); + ar = rotateRight(ar); + } + + function ror(readAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = readByte(addr); + writeByte(addr, oldVal); + var val = rotateRight(oldVal); + writeByte(addr, val); + } + + /* Logical And Accumulator */ + function and(readFn) { + ar = testNZ(ar & readFn()); + } + + /* Logical Or Accumulator */ + function ora(readFn) { + ar = testNZ(ar | readFn()); + } + + /* Logical Exclusive Or Accumulator */ + function eor(readFn) { + ar = testNZ(ar ^ readFn()); + } + + /* Reset Bit */ + + function rmb(b) { + var bit = (0x1 << b) ^ 0xFF; + var addr = readBytePC(); + var val = readByte(addr); + readByte(addr); + val &= bit; + writeByte(addr, val); + } + + /* Set Bit */ + + function smb(b) { + var bit = 0x1 << b; + var addr = readBytePC(); + var val = readByte(addr); + readByte(addr); + val |= bit; + writeByte(addr, val); + } + + /* Test and Reset Bits */ + function trb(readAddrFn) { + var addr = readAddrFn(); + var val = readByte(addr); + testZ(val & ar); + readByte(addr); + writeByte(addr, val & ~ar); + } + + /* Test and Set Bits */ + function tsb(readAddrFn) { + var addr = readAddrFn(); + var val = readByte(addr); + testZ(val & ar); + readByte(addr); + writeByte(addr, val | ar); + } + + /* Bit */ + function bit(readFn) { + var val = readFn(); + setFlag(flags.Z, (val & ar) === 0); + setFlag(flags.N, val & 0x80); + setFlag(flags.V, val & 0x40); + } + + /* Bit Immediate*/ + function bitI(readFn) { + var val = readFn(); + setFlag(flags.Z, (val & ar) === 0); + } + + function compare(a, b) + { + b = (b ^ 0xff); + var c = a + b + 1; + setFlag(flags.C, c > 0xff); + testNZ(c & 0xff); + } + + function cmp(readFn) { + compare(ar, readFn()); + } + + function cpx(readFn) { + compare(xr, readFn()); + } + + function cpy(readFn) { + compare(yr, readFn()); + } + + /* Branches */ + function brs(f) { + var off = readBytePC(); // changes pc + if ((f & sr) !== 0) { + readByte(pc); + var oldPage = pc >> 8; + pc += off > 127 ? off - 256 : off; + var newPage = pc >> 8; + var newOff = pc & 0xff; + if (newPage != oldPage) readByte(oldPage << 8 | newOff); + } + } + + function brc(f) { + var off = readBytePC(); // changes pc + if ((f & sr) === 0) { + readByte(pc); + var oldPage = pc >> 8; + pc += off > 127 ? off - 256 : off; + var newPage = pc >> 8; + var newOff = pc & 0xff; + if (newPage != oldPage) readByte(oldPage << 8 | newOff); + } + } + + /* WDC 65C02 branches */ + + function bbr(b) { + var zpAddr = readBytePC(); + var val = readByte(zpAddr); + readByte(zpAddr); + var off = readBytePC(); // changes pc + + if (((1 << b) & val) === 0) { + var oldPc = pc; + var oldPage = oldPc >> 8; + readByte(oldPc); + pc += off > 127 ? off - 256 : off; + var newPage = pc >> 8; + if (oldPage != newPage) { + readByte(oldPc); + } + } + } + + function bbs(b) { + var zpAddr = readBytePC(); + var val = readByte(zpAddr); + readByte(zpAddr); + var off = readBytePC(); // changes pc + + if (((1 << b) & val) !== 0) { + var oldPc = pc; + var oldPage = oldPc >> 8; + readByte(oldPc); + pc += off > 127 ? off - 256 : off; + var newPage = pc >> 8; + if (oldPage != newPage) { + readByte(oldPc); + } + } + } + + /* Transfers and stack */ + function tax() { readByte(pc); testNZ(xr = ar); } + + function txa() { readByte(pc); testNZ(ar = xr); } + + function tay() { readByte(pc); testNZ(yr = ar); } + + function tya() { readByte(pc); testNZ(ar = yr); } + + function tsx() { readByte(pc); testNZ(xr = sp); } + + function txs() { readByte(pc); sp = xr; } + + function pha() { readByte(pc); pushByte(ar); } + + function pla() { readByte(pc); readByte(0x0100 | sp); testNZ(ar = pullByte()); } + + function phx() { readByte(pc); pushByte(xr); } + + function plx() { readByte(pc); readByte(0x0100 | sp);testNZ(xr = pullByte()); } + + function phy() { readByte(pc); pushByte(yr); } + + function ply() { readByte(pc); readByte(0x0100 | sp); testNZ(yr = pullByte()); } + + function php() { readByte(pc); pushByte(sr | flags.B); } + + function plp() { readByte(pc); readByte(0x0100 | sp); sr = (pullByte() & ~flags.B) | 0x20; } + + /* Jump */ + function jmp(readAddrFn) { + pc = readAddrFn(); + } + + /* Jump Subroutine */ + function jsr() { + var lsb = readBytePC(); + readByte(0x0100 | sp); + pushWord(pc); + var msb = readBytePC(); + pc = (msb << 8 | lsb) & 0xffff; + } + + /* Return from Subroutine */ + function rts() { + readByte(pc); + readByte(0x0100 | sp); + var addr = pullWordRaw(); + readByte(addr); + pc = (addr + 1) & 0xffff; + } + + /* Return from Subroutine */ + function rti() { + readByte(pc); + readByte(0x0100 | sp); + sr = pullByte() & ~flags.B; + pc = pullWordRaw(); + } + + /* Set and Clear */ + function set(flag) { + readByte(pc); + sr |= flag; + } + + function clr(flag) { + readByte(pc); + sr &= ~flag; + } + + /* No-Op */ + function nop(readAddrFn) { + readByte(pc); + readAddrFn(); + } + + var ops = { + // LDA + 0xa9: ['LDA', lda, readImmediate, modes.immediate, 2], + 0xa5: ['LDA', lda, readZeroPage, modes.zeroPage, 3], + 0xb5: ['LDA', lda, readZeroPageX, modes.zeroPageX, 4], + 0xad: ['LDA', lda, readAbsolute, modes.absolute, 4], + 0xbd: ['LDA', lda, readAbsoluteX, modes.absoluteX, 4], + 0xb9: ['LDA', lda, readAbsoluteY, modes.absoluteY, 4], + 0xa1: ['LDA', lda, readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xb1: ['LDA', lda, readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // LDX + 0xa2: ['LDX', ldx, readImmediate, modes.immediate, 2], + 0xa6: ['LDX', ldx, readZeroPage, modes.zeroPage, 3], + 0xb6: ['LDX', ldx, readZeroPageY, modes.zeroPageY, 4], + 0xae: ['LDX', ldx, readAbsolute, modes.absolute, 4], + 0xbe: ['LDX', ldx, readAbsoluteY, modes.absoluteY, 4], + + // LDY + 0xa0: ['LDY', ldy, readImmediate, modes.immediate, 2], + 0xa4: ['LDY', ldy, readZeroPage, modes.zeroPage, 3], + 0xb4: ['LDY', ldy, readZeroPageX, modes.zeroPageX, 4], + 0xac: ['LDY', ldy, readAbsolute, modes.absolute, 4], + 0xbc: ['LDY', ldy, readAbsoluteX, modes.absoluteX, 4], + + // STA + 0x85: ['STA', sta, writeZeroPage, modes.zeroPage, 3], + 0x95: ['STA', sta, writeZeroPageX, modes.zeroPageX, 4], + 0x8d: ['STA', sta, writeAbsolute, modes.absolute, 4], + 0x9d: ['STA', sta, writeAbsoluteX, modes.absoluteX, 5], + 0x99: ['STA', sta, writeAbsoluteY, modes.absoluteY, 5], + 0x81: ['STA', sta, writeZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x91: ['STA', sta, writeZeroPageIndirectY, modes.zeroPageIndirectY, 6], + + // STX + 0x86: ['STX', stx, writeZeroPage, modes.zeroPage, 3], + 0x96: ['STX', stx, writeZeroPageY, modes.zeroPageY, 4], + 0x8e: ['STX', stx, writeAbsolute, modes.absolute, 4], + + // STY + 0x84: ['STY', sty, writeZeroPage, modes.zeroPage, 3], + 0x94: ['STY', sty, writeZeroPageX, modes.zeroPageX, 4], + 0x8c: ['STY', sty, writeAbsolute, modes.absolute, 4], + + // ADC + 0x69: ['ADC', adc, readImmediate, modes.immediate, 2], + 0x65: ['ADC', adc, readZeroPage, modes.zeroPage, 3], + 0x75: ['ADC', adc, readZeroPageX, modes.zeroPageX, 4], + 0x6D: ['ADC', adc, readAbsolute, modes.absolute, 4], + 0x7D: ['ADC', adc, readAbsoluteX, modes.absoluteX, 4], + 0x79: ['ADC', adc, readAbsoluteY, modes.absoluteY, 4], + 0x61: ['ADC', adc, readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x71: ['ADC', adc, readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // SBC + 0xe9: ['SBC', sbc, readImmediate, modes.immediate, 2], + 0xe5: ['SBC', sbc, readZeroPage, modes.zeroPage, 3], + 0xf5: ['SBC', sbc, readZeroPageX, modes.zeroPageX, 4], + 0xeD: ['SBC', sbc, readAbsolute, modes.absolute, 4], + 0xfD: ['SBC', sbc, readAbsoluteX, modes.absoluteX, 4], + 0xf9: ['SBC', sbc, readAbsoluteY, modes.absoluteY, 4], + 0xe1: ['SBC', sbc, readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xf1: ['SBC', sbc, readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // INC + 0xe6: ['INC', inc, readAddrZeroPage, modes.zeroPage, 5], + 0xf6: ['INC', inc, readAddrZeroPageX, modes.zeroPageX, 6], + 0xee: ['INC', inc, readAddrAbsolute, modes.absolute, 6], + 0xfe: ['INC', inc, readAddrAbsoluteX, modes.absoluteX, 7], + + // INX + 0xe8: ['INX', inx, null, modes.implied, 2], + + // INY + 0xc8: ['INY', iny, null, modes.implied, 2], + + // DEC + 0xc6: ['DEC', dec, readAddrZeroPage, modes.zeroPage, 5], + 0xd6: ['DEC', dec, readAddrZeroPageX, modes.zeroPageX, 6], + 0xce: ['DEC', dec, readAddrAbsolute, modes.absolute, 6], + 0xde: ['DEC', dec, readAddrAbsoluteX, modes.absoluteX, 7], + + // DEX + 0xca: ['DEX', dex, null, modes.implied, 2], + + // DEY + 0x88: ['DEY', dey, null, modes.implied, 2], + + // ASL + 0x0A: ['ASL', aslA, null, modes.accumulator, 2], + 0x06: ['ASL', asl, readAddrZeroPage, modes.zeroPage, 5], + 0x16: ['ASL', asl, readAddrZeroPageX, modes.zeroPageX, 6], + 0x0E: ['ASL', asl, readAddrAbsolute, modes.absolute, 6], + 0x1E: ['ASL', asl, readAddrAbsoluteX, modes.absoluteX, 7], + + // LSR + 0x4A: ['LSR', lsrA, null, modes.accumulator, 2], + 0x46: ['LSR', lsr, readAddrZeroPage, modes.zeroPage, 5], + 0x56: ['LSR', lsr, readAddrZeroPageX, modes.zeroPageX, 6], + 0x4E: ['LSR', lsr, readAddrAbsolute, modes.absolute, 6], + 0x5E: ['LSR', lsr, readAddrAbsoluteX, modes.absoluteX, 7], + + // ROL + 0x2A: ['ROL', rolA, null, modes.accumulator, 2], + 0x26: ['ROL', rol, readAddrZeroPage, modes.zeroPage, 5], + 0x36: ['ROL', rol, readAddrZeroPageX, modes.zeroPageX, 6], + 0x2E: ['ROL', rol, readAddrAbsolute, modes.absolute, 6], + 0x3E: ['ROL', rol, readAddrAbsoluteX, modes.absoluteX, 7], + + // ROR + 0x6A: ['ROR', rorA, null, modes.accumulator, 2], + 0x66: ['ROR', ror, readAddrZeroPage, modes.zeroPage, 5], + 0x76: ['ROR', ror, readAddrZeroPageX, modes.zeroPageX, 6], + 0x6E: ['ROR', ror, readAddrAbsolute, modes.absolute, 6], + 0x7E: ['ROR', ror, readAddrAbsoluteX, modes.absoluteX, 7], + + // AND + 0x29: ['AND', and, readImmediate, modes.immediate, 2], + 0x25: ['AND', and, readZeroPage, modes.zeroPage, 3], + 0x35: ['AND', and, readZeroPageX, modes.zeroPageX, 4], + 0x2D: ['AND', and, readAbsolute, modes.absolute, 4], + 0x3D: ['AND', and, readAbsoluteX, modes.absoluteX, 4], + 0x39: ['AND', and, readAbsoluteY, modes.absoluteY, 4], + 0x21: ['AND', and, readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x31: ['AND', and, readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // ORA + 0x09: ['ORA', ora, readImmediate, modes.immediate, 2], + 0x05: ['ORA', ora, readZeroPage, modes.zeroPage, 3], + 0x15: ['ORA', ora, readZeroPageX, modes.zeroPageX, 4], + 0x0D: ['ORA', ora, readAbsolute, modes.absolute, 4], + 0x1D: ['ORA', ora, readAbsoluteX, modes.absoluteX, 4], + 0x19: ['ORA', ora, readAbsoluteY, modes.absoluteY, 4], + 0x01: ['ORA', ora, readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x11: ['ORA', ora, readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // EOR + 0x49: ['EOR', eor, readImmediate, modes.immediate, 2], + 0x45: ['EOR', eor, readZeroPage, modes.zeroPage, 3], + 0x55: ['EOR', eor, readZeroPageX, modes.zeroPageX, 4], + 0x4D: ['EOR', eor, readAbsolute, modes.absolute, 4], + 0x5D: ['EOR', eor, readAbsoluteX, modes.absoluteX, 4], + 0x59: ['EOR', eor, readAbsoluteY, modes.absoluteY, 4], + 0x41: ['EOR', eor, readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x51: ['EOR', eor, readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // CMP + 0xc9: ['CMP', cmp, readImmediate, modes.immediate, 2], + 0xc5: ['CMP', cmp, readZeroPage, modes.zeroPage, 3], + 0xd5: ['CMP', cmp, readZeroPageX, modes.zeroPageX, 4], + 0xcD: ['CMP', cmp, readAbsolute, modes.absolute, 4], + 0xdD: ['CMP', cmp, readAbsoluteX, modes.absoluteX, 4], + 0xd9: ['CMP', cmp, readAbsoluteY, modes.absoluteY, 4], + 0xc1: ['CMP', cmp, readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xd1: ['CMP', cmp, readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // CPX + 0xE0: ['CPX', cpx, readImmediate, modes.immediate, 2], + 0xE4: ['CPX', cpx, readZeroPage, modes.zeroPage, 3], + 0xEC: ['CPX', cpx, readAbsolute, modes.absolute, 4], + + // CPY + 0xC0: ['CPY', cpy, readImmediate, modes.immediate, 2], + 0xC4: ['CPY', cpy, readZeroPage, modes.zeroPage, 3], + 0xCC: ['CPY', cpy, readAbsolute, modes.absolute, 4], + + // BIT + 0x24: ['BIT', bit, readZeroPage, modes.zeroPage, 3], + 0x2C: ['BIT', bit, readAbsolute, modes.absolute, 4], + + // BCC + 0x90: ['BCC', brc, flags.C, modes.relative, 2], + + // BCS + 0xB0: ['BCS', brs, flags.C, modes.relative, 2], + + // BEQ + 0xF0: ['BEQ', brs, flags.Z, modes.relative, 2], + + // BMI + 0x30: ['BMI', brs, flags.N, modes.relative, 2], + + // BNE + 0xD0: ['BNE', brc, flags.Z, modes.relative, 2], + + // BPL + 0x10: ['BPL', brc, flags.N, modes.relative, 2], + + // BVC + 0x50: ['BVC', brc, flags.V, modes.relative, 2], + + // BVS + 0x70: ['BVS', brs, flags.V, modes.relative, 2], + + // TAX + 0xAA: ['TAX', tax, null, modes.implied, 2], + + // TXA + 0x8A: ['TXA', txa, null, modes.implied, 2], + + // TAY + 0xA8: ['TAY', tay, null, modes.implied, 2], + + // TYA + 0x98: ['TYA', tya, null, modes.implied, 2], + + // TSX + 0xBA: ['TSX', tsx, null, modes.implied, 2], + + // TXS + 0x9A: ['TXS', txs, null, modes.implied, 2], + + // PHA + 0x48: ['PHA', pha, null, modes.implied, 3], + + // PLA + 0x68: ['PLA', pla, null, modes.implied, 4], + + // PHP + 0x08: ['PHP', php, null, modes.implied, 3], + + // PLP + 0x28: ['PLP', plp, null, modes.implied, 4], + + // JMP + 0x4C: [ + 'JMP', jmp, readAddrAbsolute, modes.absolute, 3 + ], + 0x6C: [ + 'JMP', jmp, readAddrAbsoluteIndirectBug, modes.absoluteIndirect, 5 + ], + // JSR + 0x20: ['JSR', jsr, readAddrAbsolute, modes.absolute, 6], + + // RTS + 0x60: ['RTS', rts, null, modes.implied, 6], + + // RTI + 0x40: ['RTI', rti, null, modes.implied, 6], + + // SEC + 0x38: ['SEC', set, flags.C, modes.implied, 2], + + // SED + 0xF8: ['SED', set, flags.D, modes.implied, 2], + + // SEI + 0x78: ['SEI', set, flags.I, modes.implied, 2], + + // CLC + 0x18: ['CLC', clr, flags.C, modes.implied, 2], + + // CLD + 0xD8: ['CLD', clr, flags.D, modes.implied, 2], + + // CLI + 0x58: ['CLI', clr, flags.I, modes.implied, 2], + + // CLV + 0xB8: ['CLV', clr, flags.V, modes.implied, 2], + + // NOP + 0xea: ['NOP', nop, readImplied, modes.implied, 2], + + // BRK + 0x00: ['BRK', brk, readImmediate, modes.immediate, 7] + }; + + /* 65C02 Instructions */ + + var cops = { + // INC / DEC A + 0x1A: ['INC', incA, null, modes.accumulator, 2], + 0x3A: ['DEC', decA, null, modes.accumulator, 2], + + // Indirect Zero Page for the masses + 0x12: ['ORA', ora, readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x32: ['AND', and, readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x52: ['EOR', eor, readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x72: ['ADC', adc, readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x92: ['STA', sta, writeZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xB2: ['LDA', lda, readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xD2: ['CMP', cmp, readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xF2: ['SBC', sbc, readZeroPageIndirect, modes.zeroPageIndirect, 5], + + // Better BIT + 0x34: ['BIT', bit, readZeroPageX, modes.zeroPageX, 4], + 0x3C: ['BIT', bit, readAbsoluteX, modes.absoluteX, 4], + 0x89: ['BIT', bitI, readImmediate, modes.immediate, 2], + + // JMP absolute indirect indexed + 0x6C: [ + 'JMP', jmp, readAddrAbsoluteIndirect, modes.absoluteIndirect, 6 + ], + 0x7C: [ + 'JMP', jmp, readAddrAbsoluteXIndirect, modes.absoluteXIndirect, 6 + ], + + // BBR/BBS + 0x0F: ['BBR0', bbr, 0, modes.zeroPage_relative, 5], + 0x1F: ['BBR1', bbr, 1, modes.zeroPage_relative, 5], + 0x2F: ['BBR2', bbr, 2, modes.zeroPage_relative, 5], + 0x3F: ['BBR3', bbr, 3, modes.zeroPage_relative, 5], + 0x4F: ['BBR4', bbr, 4, modes.zeroPage_relative, 5], + 0x5F: ['BBR5', bbr, 5, modes.zeroPage_relative, 5], + 0x6F: ['BBR6', bbr, 6, modes.zeroPage_relative, 5], + 0x7F: ['BBR7', bbr, 7, modes.zeroPage_relative, 5], + + 0x8F: ['BBS0', bbs, 0, modes.zeroPage_relative, 5], + 0x9F: ['BBS1', bbs, 1, modes.zeroPage_relative, 5], + 0xAF: ['BBS2', bbs, 2, modes.zeroPage_relative, 5], + 0xBF: ['BBS3', bbs, 3, modes.zeroPage_relative, 5], + 0xCF: ['BBS4', bbs, 4, modes.zeroPage_relative, 5], + 0xDF: ['BBS5', bbs, 5, modes.zeroPage_relative, 5], + 0xEF: ['BBS6', bbs, 6, modes.zeroPage_relative, 5], + 0xFF: ['BBS7', bbs, 7, modes.zeroPage_relative, 5], + + // BRA + 0x80: ['BRA', brc, 0, modes.relative, 2], + + // NOP + 0x02: ['NOP', nop, readImmediate, modes.immediate, 2], + 0x22: ['NOP', nop, readImmediate, modes.immediate, 2], + 0x42: ['NOP', nop, readImmediate, modes.immediate, 2], + 0x44: ['NOP', nop, readImmediate, modes.immediate, 3], + 0x54: ['NOP', nop, readImmediate, modes.immediate, 4], + 0x62: ['NOP', nop, readImmediate, modes.immediate, 2], + 0x82: ['NOP', nop, readImmediate, modes.immediate, 2], + 0xC2: ['NOP', nop, readImmediate, modes.immediate, 2], + 0xD4: ['NOP', nop, readImmediate, modes.immediate, 4], + 0xE2: ['NOP', nop, readImmediate, modes.immediate, 2], + 0xF4: ['NOP', nop, readImmediate, modes.immediate, 4], + 0x5C: ['NOP', nop, readAbsolute, modes.absolute, 8], + 0xDC: ['NOP', nop, readAbsolute, modes.absolute, 4], + 0xFC: ['NOP', nop, readAbsolute, modes.absolute, 4], + + // PHX + 0xDA: ['PHX', phx, null, modes.implied, 3], + + // PHY + 0x5A: ['PHY', phy, null, modes.implied, 3], + + // PLX + 0xFA: ['PLX', plx, null, modes.implied, 4], + + // PLY + 0x7A: ['PLY', ply, null, modes.implied, 4], + + // RMB/SMB + + 0x07: ['RMB0', rmb, 0, modes.zeroPage, 5], + 0x17: ['RMB1', rmb, 1, modes.zeroPage, 5], + 0x27: ['RMB2', rmb, 2, modes.zeroPage, 5], + 0x37: ['RMB3', rmb, 3, modes.zeroPage, 5], + 0x47: ['RMB4', rmb, 4, modes.zeroPage, 5], + 0x57: ['RMB5', rmb, 5, modes.zeroPage, 5], + 0x67: ['RMB6', rmb, 6, modes.zeroPage, 5], + 0x77: ['RMB7', rmb, 7, modes.zeroPage, 5], + + 0x87: ['SMB0', smb, 0, modes.zeroPage, 5], + 0x97: ['SMB1', smb, 1, modes.zeroPage, 5], + 0xA7: ['SMB2', smb, 2, modes.zeroPage, 5], + 0xB7: ['SMB3', smb, 3, modes.zeroPage, 5], + 0xC7: ['SMB4', smb, 4, modes.zeroPage, 5], + 0xD7: ['SMB5', smb, 5, modes.zeroPage, 5], + 0xE7: ['SMB6', smb, 6, modes.zeroPage, 5], + 0xF7: ['SMB7', smb, 7, modes.zeroPage, 5], + + // STZ + 0x64: ['STZ', stz, writeZeroPage, modes.zeroPage, 3], + 0x74: ['STZ', stz, writeZeroPageX, modes.zeroPageX, 4], + 0x9C: ['STZ', stz, writeAbsolute, modes.absolute, 4], + 0x9E: ['STZ', stz, writeAbsoluteX, modes.absoluteX, 5], + + // TRB + 0x14: ['TRB', trb, readAddrZeroPage, modes.zeroPage, 5], + 0x1C: ['TRB', trb, readAddrAbsolute, modes.absolute, 6], + + // TSB + 0x04: ['TSB', tsb, readAddrZeroPage, modes.zeroPage, 5], + 0x0C: ['TSB', tsb, readAddrAbsolute, modes.absolute, 6] + }; + + if (is65C02) { + Object.assign(ops, cops); + } + + function unknown(b) { + var unk; + + if (is65C02) { + unk = [ + 'NOP', + nop, + readImplied, + modes.implied, + 2 + ]; + } else { + unk = [ + '???', + function() { + debug('Unknown OpCode: ' + toHex(b) + + ' at ' + toHex(pc - 1, 4)); + }, + readImplied, + modes.implied, + 1 + ]; + } + ops[b] = unk; + return unk; + } + + /* Certain browsers benefit from using arrays over maps */ + var opary = []; + + for (idx = 0; idx < 0x100; idx++) { + opary[idx] = ops[idx] || unknown(idx); + } + + function dumpArgs(addr, m, symbols) { + var val; + var off; + function toHexOrSymbol(v, n) { + if (symbols && symbols[v]) { + return symbols[v]; + } else { + return '$' + toHex(v, n); + } + } + var result = ''; + switch (m) { + case modes.implied: + break; + case modes.immediate: + result = '#' + toHexOrSymbol(readByteDebug(addr)); + break; + case modes.absolute: + result = '' + toHexOrSymbol(readWordDebug(addr), 4); + break; + case modes.zeroPage: + result = '' + toHexOrSymbol(readByteDebug(addr)); + break; + case modes.relative: + { + off = readByteDebug(addr); + if (off > 127) { + off -= 256; + } + addr += off + 1; + result = '' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + } + break; + case modes.absoluteX: + result = '' + toHexOrSymbol(readWordDebug(addr), 4) + ',X'; + break; + case modes.absoluteY: + result = '' + toHexOrSymbol(readWordDebug(addr), 4) + ',Y'; + break; + case modes.zeroPageX: + result = '' + toHexOrSymbol(readByteDebug(addr)) + ',X'; + break; + case modes.zeroPageY: + result = '' + toHexOrSymbol(readByteDebug(addr)) + ',Y'; + break; + case modes.absoluteIndirect: + result = '(' + toHexOrSymbol(readWordDebug(addr), 4) + ')'; + break; + case modes.zeroPageXIndirect: + result = '(' + toHexOrSymbol(readByteDebug(addr)) + ',X)'; + break; + case modes.zeroPageIndirectY: + result = '(' + toHexOrSymbol(readByteDebug(addr)) + '),Y'; + break; + case modes.accumulator: + result = 'A'; + break; + case modes.zeroPageIndirect: + result = '(' + toHexOrSymbol(readByteDebug(addr)) + ')'; + break; + case modes.absoluteXIndirect: + result = '(' + toHexOrSymbol(readWordDebug(addr), 4) + ',X)'; + break; + case modes.zeroPage_relative: + val = readByteDebug(addr); + off = readByteDebug(addr + 1); + if (off > 127) { + off -= 256; + } + addr += off + 2; + result = '' + toHexOrSymbol(val) + ',' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + break; + default: + break; + } + return result; + } + + return { + step: function cpu_step(cb) { + sync = true; + var op = opary[readBytePC()]; + sync = false; + op[1](op[2]); + + if (cb) { + cb(this); + } + }, + + stepDebug: function(n, cb) { + var op, idx; + + for (idx = 0; idx < n; idx++) { + sync = true; + op = opary[readBytePC()]; + sync = false; + op[1](op[2]); + + if (cb) { + cb(this); + } + } + }, + + stepCycles: function(c) { + var op, end = cycles + c; + + while (cycles < end) { + sync = true; + op = opary[readBytePC()]; + sync = false; + op[1](op[2]); + } + }, + + stepCyclesDebug: function(c, cb) + { + var op, end = cycles + c; + + while (cycles < end) { + sync = true; + op = opary[readBytePC()]; + sync = false; + op[1](op[2]); + + if (cb) { + cb(this); + } + } + }, + + addPageHandler: function(pho) { + for (var idx = pho.start(); idx <= pho.end(); idx++) { + if (pho.read) + readPages[idx] = pho; + if (pho.write) + writePages[idx] = pho; + } + if (pho.reset) + resetHandlers.push(pho); + }, + + reset: function cpu_reset() + { + // cycles = 0; + sr = 0x20; + sp = 0xff; + ar = 0; + yr = 0; + xr = 0; + pc = readWord(loc.RESET); + + for (var idx = 0; idx < resetHandlers.length; idx++) { + resetHandlers[idx].reset(); + } + }, + + /* IRQ - Interrupt Request */ + irq: function cpu_irq() + { + if ((sr & flags.I) === 0) { + pushWord(pc); + pushByte(sr & ~flags.B); + if (is65C02) { + setFlag(flags.D, false); + } + setFlag(flags.I, true); + pc = readWord(loc.BRK); + } + }, + + /* NMI Non-maskable Interrupt */ + nmi: function cpu_nmi() + { + pushWord(pc); + pushByte(sr & ~flags.B); + if (is65C02) { + setFlag(flags.D, false); + } + setFlag(flags.I, true); + pc = readWord(loc.NMI); + }, + + getPC: function () { + return pc; + }, + + setPC: function(_pc) { + pc = _pc; + }, + + dumpPC: function(_pc, symbols) { + if (_pc === undefined) { + _pc = pc; + } + var b = readByte(_pc, true), + op = ops[b], + size = sizes[op[3]], + result = toHex(_pc, 4) + '- '; + + if (symbols) { + if (symbols[_pc]) { + result += symbols[_pc] + + ' '.substring(symbols[_pc].length); + } else { + result += ' '; + } + } + + for (var idx = 0; idx < 4; idx++) { + if (idx < size) { + result += toHex(readByte(_pc + idx, true)) + ' '; + } else { + result += ' '; + } + } + + if (op === undefined) + result += '??? (' + toHex(b) + ')'; + else + result += op[0] + ' ' + dumpArgs(_pc + 1, op[3], symbols); + + return result; + }, + + dumpPage: function(start, end) { + var result = ''; + if (start === undefined) { + start = pc >> 8; + } + if (end === undefined) { + end = start; + } + for (var page = start; page <= end; page++) { + var b, idx, jdx; + for (idx = 0; idx < 16; idx++) { + result += toHex(page) + toHex(idx << 4) + ': '; + for (jdx = 0; jdx < 16; jdx++) { + b = readByteDebug(page * 256 + idx * 16 + jdx); + result += toHex(b) + ' '; + } + result += ' '; + for (jdx = 0; jdx < 16; jdx++) { + b = readByte(page * 256 + idx * 16 + jdx, true) & 0x7f; + if (b >= 0x20 && b < 0x7f) { + result += String.fromCharCode(b); + } else { + result += '.'; + } + } + result += '\n'; + } + } + return result; + }, + + list: function(_pc, symbols) { + if (_pc === undefined) { + _pc = pc; + } + var results = []; + for (var jdx = 0; jdx < 20; jdx++) { + var b = readByte(_pc), op = ops[b]; + results.push(this.dumpPC(_pc, symbols)); + _pc += sizes[op[3]]; + } + return results; + }, + + sync: function() { + return sync; + }, + + cycles: function() { + return cycles; + }, + + registers: function() { + return [pc,ar,xr,yr,sr,sp]; + }, + + getState: function() { + return { + a: ar, + x: xr, + y: yr, + s: sr, + pc: pc, + sp: sp, + cycles: cycles + }; + }, + + setState: function(state) { + ar = state.a; + xr = state.x; + yr = state.y; + sr = state.s; + pc = state.pc; + sp = state.sp; + cycles = state.cycles; + }, + + dumpRegisters: function() { + return toHex(pc, 4) + + '- A=' + toHex(ar) + + ' X=' + toHex(xr) + + ' Y=' + toHex(yr) + + ' P=' + toHex(sr) + + ' S=' + toHex(sp) + + ' ' + + ((sr & flags.N) ? 'N' : '-') + + ((sr & flags.V) ? 'V' : '-') + + '-' + + ((sr & flags.B) ? 'B' : '-') + + ((sr & flags.D) ? 'D' : '-') + + ((sr & flags.I) ? 'I' : '-') + + ((sr & flags.Z) ? 'Z' : '-') + + ((sr & flags.C) ? 'C' : '-'); + }, + + read: function(page, off) { + return readPages[page].read(page, off); + }, + + write: function(page, off, val) { + writePages[page].write(page, off, val); + } + }; +} diff --git a/test/perf/impl/tscpu6502.ts b/test/perf/impl/tscpu6502.ts new file mode 100644 index 00000000..5e2d3fce --- /dev/null +++ b/test/perf/impl/tscpu6502.ts @@ -0,0 +1,1759 @@ +/* + * Copyright 2010-2019 Will Scullin + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +import { byte, word } from '../../../js/types'; +import { debug, toHex } from '../../../js/util'; + +type symbols = { [key: number]: string }; + +export interface CpuOptions { + '65C02'?: boolean; +} + +export interface CpuState { + a: byte, + x: byte, + y: byte, + s: byte, + pc: word, + sp: byte, + cycles: number +} + +/** Range of mode numbers. */ +type mode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15; + +/** Addressing mode name to number mapping. */ +const modes: { [key: string]: mode } = { + accumulator: 0, // A (Accumulator) + implied: 1, // Implied + immediate: 2, // # Immediate + absolute: 3, // a Absolute + zeroPage: 4, // zp Zero Page + relative: 5, // r Relative + + absoluteX: 6, // a,X Absolute, X + absoluteY: 7, // a,Y Absolute, Y + zeroPageX: 8, // zp,X Zero Page, X + zeroPageY: 9, // zp,Y Zero Page, Y + + absoluteIndirect: 10, // (a) Indirect + zeroPageXIndirect: 11, // (zp,X) Zero Page Indexed Indirect + zeroPageIndirectY: 12, // (zp),Y Zero Page Indexed with Y + + /* 65c02 */ + zeroPageIndirect: 13, // (zp), + absoluteXIndirect: 14, // (a, X), + zeroPage_relative: 15 // zp, Relative +}; + +/** Instruction size by addressing mode. */ +const sizes = { + 0 /* modes.accumulator */: 1, + 1 /* modes.implied */: 1, + 2 /* modes.immediate */: 2, + 3 /* modes.absolute */: 3, + 4 /* modes.zeroPage */: 2, + 5 /* modes.relative */: 2, + 6 /* modes.absoluteX */: 3, + 7 /* modes.absoluteY */: 3, + 8 /* modes.zeroPageX */: 2, + 9 /* modes.zeroPageY */: 2, + 10 /* modes.indirect */: 3, + 11 /* modes.zeroPageXIndirect */: 2, + 12 /* modes.zeroPageYIndirect */: 2, + + 13 /* mode.zeroPageIndirect */: 2, + 14 /* mode.absoluteXIndirect */: 3, + 15 /* mode.zeroPage_relative */: 3 +}; + +/** Status register flag numbers. */ +type flag = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7; + +/** Flags to status byte mask. */ +const flags = { + N: 0x80, // Negative + V: 0x40, // oVerflow + B: 0x10, // Break + D: 0x08, // Decimal + I: 0x04, // Interrupt + Z: 0x02, // Zero + C: 0x01 // Carry +}; + +/** CPU-referenced memory locations. */ +const loc = { + STACK: 0x100, + NMI: 0xFFFA, + RESET: 0xFFFC, + BRK: 0xFFFE +}; + +interface ReadablePage { + read(page: byte, offset: byte): byte; +} + +function isReadablePage(page: ReadablePage | any): page is ReadablePage { + return (page as ReadablePage).read !== undefined; +} + +interface WriteablePage { + write(page: byte, offset: byte, value: byte): void; +} + +function isWriteablePage(page: WriteablePage | any): page is WriteablePage { + return (page as WriteablePage).write !== undefined; +} + +interface PageHandler { + start(): byte; + end(): byte; +} + +function isResettablePageHandler(pageHandler: PageHandler | ResettablePageHandler): pageHandler is ResettablePageHandler { + return (pageHandler as ResettablePageHandler).reset !== undefined; +} + +interface ResettablePageHandler extends PageHandler { + reset(): void; +} + +const BLANK_PAGE: ReadablePage & WriteablePage = { + read: function() { return 0; }, + write: function() {} +}; + +interface Opts { + rwm?: boolean; +} + +type ReadFn = () => byte; +type WriteFn = (val: byte) => void; +type ReadAddrFn = (opts?: Opts) => word; + +type readInstruction = [ + desc: string, + op: (readFn: ReadFn) => void, + modeFn: ReadFn, + mode: mode, // really 0-15 + cycles: number, +]; + +type writeInstruction = [ + desc: string, + op: (writeFn: WriteFn) => void, + modeFn: WriteFn, + mode: mode, // really 0-15 + cycles: number, +]; + +type impliedInstruction = [ + desc: string, + op: () => void, + modeFn: null, + mode: mode, // really 0-15 + cycles: number, +]; + +type relativeInstruction = [ + desc: string, + op: (f: byte) => void, + modeFn: byte, + mode: mode, // really 0-15 + cycles: number, +]; + +type noopInstruction = [ + desc: string, + op: (readAddrFn: ReadAddrFn) => void, + modeFn: () => void, + mode: mode, // really 0-15 + cycles: number, +]; + +type instruction = + readInstruction | writeInstruction | + impliedInstruction | relativeInstruction | noopInstruction; + +interface Instructions { + [key: number]: instruction; +} + +type callback = (cpu: any) => void; // TODO(flan): Hack until there is better typing. + +function bind(op: instruction, o: CPU6502): instruction { + let op2: instruction[2] = typeof op[2] === "function" ? op[2].bind(o) : op[2]; + return [op[0], op[1].bind(o), op2, op[3], op[4]]; +} + +export default class CPU6502 { + private readonly is65C02; + + /* Registers */ + private pc = 0; // Program Counter + private sr = 0x20; // Process Status Register + private ar = 0; // Accumulator + private xr = 0; // X Register + private yr = 0; // Y Register + private sp = 0xff; // Stack Pointer + + private readPages: ReadablePage[] = []; + private writePages: WriteablePage[] = []; + private resetHandlers: ResettablePageHandler[] = []; + private cycles = 0; + private sync = false; + + private readonly ops: Instructions; + private readonly opary: instruction[]; + + constructor(options: CpuOptions = {}) { + this.is65C02 = options['65C02'] ? true : false; + + for (let idx = 0; idx < 0x100; idx++) { + this.readPages[idx] = BLANK_PAGE; + this.writePages[idx] = BLANK_PAGE; + } + + // Create this CPU's instruction table + let ops: Instructions = []; + Object.assign(ops, OPS_6502); + if (this.is65C02) { + Object.assign(ops, OPS_65C02); + } + this.ops = ops; + + // Certain browsers benefit from using arrays over maps + let opary: instruction[] = []; + + for (let idx = 0; idx < 0x100; idx++) { + opary[idx] = bind(ops[idx] || this.unknown(idx), this); + } + this.opary = opary; + } + + /** + * Set or clears `f` in the status register. `f` must be a byte with a + * single bit set. + */ + private setFlag(f: byte, on: boolean) { + this.sr = on ? (this.sr | f) : (this.sr & ~f); + } + + /** Updates the status register's zero flag and negative flag. */ + private testNZ(val: byte) { + this.sr = val === 0 ? (this.sr | flags.Z) : (this.sr & ~flags.Z); + this.sr = (val & 0x80) ? (this.sr | flags.N) : (this.sr & ~flags.N); + + return val; + } + + /** Updates the status register's zero flag. */ + private testZ(val: byte) { + this.sr = val === 0 ? (this.sr | flags.Z) : (this.sr & ~flags.Z); + + return val; + } + + /** + * Returns `a + b`, unless `sub` is true, in which case it performs + * `a - b`. The status register is updated according to the result. + */ + private add(a: byte, b: byte, sub: boolean) { + if (sub) + b ^= 0xff; + + // KEGS + var c, v; + if ((this.sr & flags.D) !== 0) { + // BCD + c = (a & 0x0f) + (b & 0x0f) + (this.sr & flags.C); + if (sub) { + if (c < 0x10) + c = (c - 0x06) & 0x0f; + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c < 0x100) + c = (c + 0xa0) & 0xff; + } else { + if (c > 0x09) + c = (c - 0x0a) | 0x10; // carry to MSN + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c > 0x99) + c += 0x60; + } + } else { + c = a + b + (this.sr & flags.C); + v = (c ^ a) & 0x80; + } + + if (((a ^ b) & 0x80) !== 0) { + v = 0; + } + + this.setFlag(flags.C, c > 0xff); + this.setFlag(flags.V, !!v); + + return this.testNZ(c & 0xff); + } + + /** Increments `a` and returns the value, setting the status register. */ + private increment(a: byte) { + return this.testNZ((a + 0x01) & 0xff); + } + + private decrement(a: byte) { + return this.testNZ((a + 0xff) & 0xff); + } + + private readBytePC(): byte { + let addr = this.pc, + page = addr >> 8, + off = addr & 0xff; + + var result = this.readPages[page].read(page, off); + + this.pc = (this.pc + 1) & 0xffff; + + this.cycles++; + + return result; + } + + private readByte(addr: word): byte { + var page = addr >> 8, + off = addr & 0xff; + + var result = this.readPages[page].read(page, off); + + this.cycles++; + + return result; + } + + private readByteDebug(addr: word) { + var page = addr >> 8, + off = addr & 0xff; + + return this.readPages[page].read(page, off); + } + + private writeByte(addr: word, val: byte) { + var page = addr >> 8, + off = addr & 0xff; + + this.writePages[page].write(page, off, val); + + this.cycles++; + } + + private readWord(addr: word): word { + return this.readByte(addr) | (this.readByte(addr + 1) << 8); + } + + private readWordDebug(addr: word): word { + return this.readByteDebug(addr) | (this.readByteDebug(addr + 1) << 8); + } + + private readWordPC(): word { + return this.readBytePC() | (this.readBytePC() << 8); + } + + private readZPWord(addr: byte): word { + var lsb, msb; + + lsb = this.readByte(addr & 0xff); + msb = this.readByte((addr + 1) & 0xff); + + return (msb << 8) | lsb; + } + + private pushByte(val: byte) { + this.writeByte(loc.STACK | this.sp, val); + this.sp = (this.sp + 0xff) & 0xff; + } + + private pushWord(val: word) { + this.pushByte(val >> 8); + this.pushByte(val & 0xff); + } + + private pullByte(): byte { + this.sp = (this.sp + 0x01) & 0xff; + return this.readByte(loc.STACK | this.sp); + } + + private pullWordRaw(): word { + var lsb = this.pullByte(); + var msb = this.pullByte(); + + return (msb << 8) | lsb; + } + + /* + * Read functions + */ + + readImplied() { + } + + // #$00 + readImmediate(): byte { + return this.readBytePC(); + } + + // $0000 + readAbsolute(): byte { + return this.readByte(this.readWordPC()); + } + + // $00 + readZeroPage(): byte { + return this.readByte(this.readBytePC()); + } + + // $0000,X + readAbsoluteX(): byte { + var addr = this.readWordPC(); + var oldPage = addr >> 8; + addr = (addr + this.xr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // $0000,Y + readAbsoluteY(): byte { + var addr = this.readWordPC(); + var oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // $00,X + readZeroPageX(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return this.readByte((zpAddr + this.xr) & 0xff); + } + + // $00,Y + readZeroPageY(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return this.readByte((zpAddr + this.yr) & 0xff); + } + + // ($00,X) + readZeroPageXIndirect(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + var addr = this.readZPWord((zpAddr + this.xr) & 0xff); + return this.readByte(addr); + } + + // ($00),Y + readZeroPageIndirectY(): byte { + var addr = this.readZPWord(this.readBytePC()); + var oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // ($00) (65C02) + readZeroPageIndirect(): byte { + return this.readByte(this.readZPWord(this.readBytePC())); + } + + /* + * Write Functions + */ + + // $0000 + writeAbsolute(val: byte) { + this.writeByte(this.readWordPC(), val); + } + + // $00 + writeZeroPage(val: byte) { + this.writeByte(this.readBytePC(), val); + } + + // $0000,X + writeAbsoluteX(val: byte) { + var addr = this.readWordPC(), oldPage = addr >> 8; + addr = (addr + this.xr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // $0000,Y + writeAbsoluteY(val: byte) { + var addr = this.readWordPC(), oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // $00,X + writeZeroPageX(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + this.writeByte((zpAddr + this.xr) & 0xff, val); + } + + // $00,Y + writeZeroPageY(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + this.writeByte((zpAddr + this.yr) & 0xff, val); + } + + // ($00,X) + writeZeroPageXIndirect(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + var addr = this.readZPWord((zpAddr + this.xr) & 0xff); + this.writeByte(addr, val); + } + + // ($00),Y + writeZeroPageIndirectY(val: byte) { + var addr = this.readZPWord(this.readBytePC()), oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // ($00) (65C02) + writeZeroPageIndirect(val: byte) { + this.writeByte(this.readZPWord(this.readBytePC()), val); + } + + // $00 + readAddrZeroPage(): byte { + return this.readBytePC(); + } + + // $00,X + readAddrZeroPageX() { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return (zpAddr + this.xr) & 0xff; + } + + // $0000 (65C02) + readAddrAbsolute(): word { + return this.readWordPC(); + } + + // ($0000) (6502) + readAddrAbsoluteIndirectBug(): word { + var addr = this.readWordPC(); + var page = addr & 0xff00; + var off = addr & 0x00ff; + var lsb = this.readByte(addr); + var msb = this.readByte(page | ((off + 0x01) & 0xff)); + return msb << 8 | lsb; + } + + // ($0000) (65C02) + readAddrAbsoluteIndirect(): word { + var lsb = this.readBytePC(); + var msb = this.readBytePC(); + this.readByte(this.pc); + return this.readWord(msb << 8 | lsb); + } + + // $0000,X + readAddrAbsoluteX(opts: Opts = {}): word { + var addr = this.readWordPC(); + if (!this.is65C02 || opts.rwm) { + this.readByte(addr); + } else { + this.readByte(this.pc); + } + return (addr + this.xr) & 0xffff; + } + + // $(0000,X) (65C02) + readAddrAbsoluteXIndirect(): word { + var address = this.readWordPC(); + this.readByte(this.pc); + return this.readWord((address + this.xr) & 0xffff); + } + + /* Break */ + brk(readFn: ReadFn) { + readFn(); + this.pushWord(this.pc); + this.pushByte(this.sr | flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.BRK); + } + + /* Load Accumulator */ + lda(readFn: ReadFn) { + this.ar = this.testNZ(readFn()); + } + + /* Load X Register */ + ldx(readFn: ReadFn) { + this.xr = this.testNZ(readFn()); + } + + /* Load Y Register */ + ldy(readFn: ReadFn) { + this.yr = this.testNZ(readFn()); + } + + /* Store Accumulator */ + sta(writeFn: WriteFn) { + writeFn(this.ar); + } + + /* Store X Register */ + stx(writeFn: WriteFn) { + writeFn(this.xr); + } + + /* Store Y Register */ + sty(writeFn: WriteFn) { + writeFn(this.yr); + } + + /* Store Zero */ + stz(writeFn: WriteFn) { + writeFn(0); + } + + /* Add with Carry */ + adc(readFn: ReadFn) { + this.ar = this.add(this.ar, readFn(), /* sub= */ false); + } + + /* Subtract with Carry */ + sbc(readFn: ReadFn) { + this.ar = this.add(this.ar, readFn(), /* sub= */ true); + } + + /* Increment Memory */ + incA() { + this.readByte(this.pc); + this.ar = this.increment(this.ar); + } + + inc(readAddrFn: ReadAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.increment(oldVal); + this.writeByte(addr, val); + } + + /* Increment X */ + inx() { + this.readByte(this.pc); + this.xr = this.increment(this.xr); + } + + /* Increment Y */ + iny() { + this.readByte(this.pc); + this.yr = this.increment(this.yr); + } + + /* Decrement Memory */ + decA() { + this.readByte(this.pc); + this.ar = this.decrement(this.ar); + } + + dec(readAddrFn: ReadAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.decrement(oldVal); + this.writeByte(addr, val); + } + + /* Decrement X */ + dex() { + this.readByte(this.pc); + this.xr = this.decrement(this.xr); + } + + /* Decrement Y */ + dey() { + this.readByte(this.pc); + this.yr = this.decrement(this.yr); + } + + shiftLeft(val: byte) { + this.setFlag(flags.C, !!(val & 0x80)); + return this.testNZ((val << 1) & 0xff); + } + + /* Arithmetic Shift Left */ + aslA() { + this.readByte(this.pc); + this.ar = this.shiftLeft(this.ar); + } + + asl(readAddrFn: ReadAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.shiftLeft(oldVal); + this.writeByte(addr, val); + } + + shiftRight(val: byte) { + this.setFlag(flags.C, !!(val & 0x01)); + return this.testNZ(val >> 1); + } + + /* Logical Shift Right */ + lsrA() { + this.readByte(this.pc); + this.ar = this.shiftRight(this.ar); + } + + lsr(readAddrFn: ReadAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.shiftRight(oldVal); + this.writeByte(addr, val); + } + + rotateLeft(val: byte) { + var c = (this.sr & flags.C); + this.setFlag(flags.C, !!(val & 0x80)); + return this.testNZ(((val << 1) | (c ? 0x01 : 0x00)) & 0xff); + } + + /* Rotate Left */ + rolA() { + this.readByte(this.pc); + this.ar = this.rotateLeft(this.ar); + } + + rol(readAddrFn: ReadAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.rotateLeft(oldVal); + this.writeByte(addr, val); + } + + private rotateRight(a: byte) { + var c = (this.sr & flags.C); + this.setFlag(flags.C, !!(a & 0x01)); + return this.testNZ((a >> 1) | (c ? 0x80 : 0x00)); + } + + /* Rotate Right */ + rorA() { + this.readByte(this.pc); + this.ar = this.rotateRight(this.ar); + } + + ror(readAddrFn: ReadAddrFn) { + var addr = readAddrFn({rwm: true}); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.rotateRight(oldVal); + this.writeByte(addr, val); + } + + /* Logical And Accumulator */ + and(readFn: ReadFn) { + this.ar = this.testNZ(this.ar & readFn()); + } + + /* Logical Or Accumulator */ + ora(readFn: ReadFn) { + this.ar = this.testNZ(this.ar | readFn()); + } + + /* Logical Exclusive Or Accumulator */ + eor(readFn: ReadFn) { + this.ar = this.testNZ(this.ar ^ readFn()); + } + + /* Reset Bit */ + + rmb(b: byte) { + var bit = (0x1 << b) ^ 0xFF; + var addr = this.readBytePC(); + var val = this.readByte(addr); + this.readByte(addr); + val &= bit; + this.writeByte(addr, val); + } + + /* Set Bit */ + + smb(b: byte) { + var bit = 0x1 << b; + var addr = this.readBytePC(); + var val = this.readByte(addr); + this.readByte(addr); + val |= bit; + this.writeByte(addr, val); + } + + /* Test and Reset Bits */ + trb(readAddrFn: ReadAddrFn) { + var addr = readAddrFn(); + var val = this.readByte(addr); + this.testZ(val & this.ar); + this.readByte(addr); + this.writeByte(addr, val & ~this.ar); + } + + /* Test and Set Bits */ + tsb(readAddrFn: ReadAddrFn) { + var addr = readAddrFn(); + var val = this.readByte(addr); + this.testZ(val & this.ar); + this.readByte(addr); + this.writeByte(addr, val | this.ar); + } + + /* Bit */ + bit(readFn: ReadFn) { + var val = readFn(); + this.setFlag(flags.Z, (val & this.ar) === 0); + this.setFlag(flags.N, !!(val & 0x80)); + this.setFlag(flags.V, !!(val & 0x40)); + } + + /* Bit Immediate*/ + bitI(readFn: ReadFn) { + var val = readFn(); + this.setFlag(flags.Z, (val & this.ar) === 0); + } + + private compare(a: byte, b: byte) { + b = (b ^ 0xff); + var c = a + b + 1; + this.setFlag(flags.C, c > 0xff); + this.testNZ(c & 0xff); + } + + cmp(readFn: ReadFn) { + this.compare(this.ar, readFn()); + } + + cpx(readFn: ReadFn) { + this.compare(this.xr, readFn()); + } + + cpy(readFn: ReadFn) { + this.compare(this.yr, readFn()); + } + + /* Branches */ + brs(f: flag) { + let off = this.readBytePC(); // changes pc + if ((f & this.sr) !== 0) { + this.readByte(this.pc); + let oldPage = this.pc >> 8; + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + let newOff = this.pc & 0xff; + if (newPage != oldPage) this.readByte(oldPage << 8 | newOff); + } + } + + brc(f: flag) { + let off = this.readBytePC(); // changes pc + if ((f & this.sr) === 0) { + this.readByte(this.pc); + let oldPage = this.pc >> 8; + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + let newOff = this.pc & 0xff; + if (newPage != oldPage) this.readByte(oldPage << 8 | newOff); + } + } + + /* WDC 65C02 branches */ + + bbr(b: flag) { + let zpAddr = this.readBytePC(); + let val = this.readByte(zpAddr); + this.readByte(zpAddr); + let off = this.readBytePC(); // changes pc + + if (((1 << b) & val) === 0) { + let oldPc = this.pc; + let oldPage = oldPc >> 8; + this.readByte(oldPc); + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + if (oldPage != newPage) { + this.readByte(oldPc); + } + } + } + + bbs(b: flag) { + let zpAddr = this.readBytePC(); + let val = this.readByte(zpAddr); + this.readByte(zpAddr); + let off = this.readBytePC(); // changes pc + + if (((1 << b) & val) !== 0) { + let oldPc = this.pc; + let oldPage = oldPc >> 8; + this.readByte(oldPc); + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + if (oldPage != newPage) { + this.readByte(oldPc); + } + } + } + + /* Transfers and stack */ + tax() { this.readByte(this.pc); this.testNZ(this.xr = this.ar); } + + txa() { this.readByte(this.pc); this.testNZ(this.ar = this.xr); } + + tay() { this.readByte(this.pc); this.testNZ(this.yr = this.ar); } + + tya() { this.readByte(this.pc); this.testNZ(this.ar = this.yr); } + + tsx() { this.readByte(this.pc); this.testNZ(this.xr = this.sp); } + + txs() { this.readByte(this.pc); this.sp = this.xr; } + + pha() { this.readByte(this.pc); this.pushByte(this.ar); } + + pla() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.ar = this.pullByte()); } + + phx() { this.readByte(this.pc); this.pushByte(this.xr); } + + plx() { this.readByte(this.pc); this.readByte(0x0100 | this.sp);this.testNZ(this.xr = this.pullByte()); } + + phy() { this.readByte(this.pc); this.pushByte(this.yr); } + + ply() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.yr = this.pullByte()); } + + php() { this.readByte(this.pc); this.pushByte(this.sr | flags.B); } + + plp() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.sr = (this.pullByte() & ~flags.B) | 0x20; } + + /* Jump */ + jmp(readAddrFn: ReadAddrFn) { + this.pc = readAddrFn(); + } + + /* Jump Subroutine */ + jsr() { + let lsb = this.readBytePC(); + this.readByte(0x0100 | this.sp); + this.pushWord(this.pc); + let msb = this.readBytePC(); + this.pc = (msb << 8 | lsb) & 0xffff; + } + + /* Return from Subroutine */ + rts() { + this.readByte(this.pc); + this.readByte(0x0100 | this.sp); + let addr = this.pullWordRaw(); + this.readByte(addr); + this.pc = (addr + 1) & 0xffff; + } + + /* Return from Interrupt */ + rti() { + this.readByte(this.pc); + this.readByte(0x0100 | this.sp); + this.sr = this.pullByte() & ~flags.B; + this.pc = this.pullWordRaw(); + } + + /* Set and Clear */ + set(flag: flag) { + this.readByte(this.pc); + this.sr |= flag; + } + + clr(flag: flag) { + this.readByte(this.pc); + this.sr &= ~flag; + } + + /* No-Op */ + nop(readAddrFn: ReadAddrFn) { + this.readByte(this.pc); + readAddrFn(); + } + + private unknown(b: byte) { + let unk: noopInstruction; + + if (this.is65C02) { + unk = [ + 'NOP', + this.nop, + this.readImplied, + modes.implied, + 2 + ]; + } else { + unk = [ + '???', + function() { + debug('Unknown OpCode: ' + toHex(b) + + ' at ' + toHex(this.pc - 1, 4)); + }, + this.readImplied, + modes.implied, + 1 + ]; + } + this.ops[b] = unk; + return unk; + } + + private dumpArgs(addr: word, m: mode, symbols: symbols) { + function toHexOrSymbol(v: word, n?: number) { + if (symbols && symbols[v]) { + return symbols[v]; + } else { + return '$' + toHex(v, n); + } + } + + let result = ''; + switch (m) { + case modes.implied: + break; + case modes.immediate: + result = '#' + toHexOrSymbol(this.readByteDebug(addr)); + break; + case modes.absolute: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4); + break; + case modes.zeroPage: + result = '' + toHexOrSymbol(this.readByteDebug(addr)); + break; + case modes.relative: + { + let off = this.readByteDebug(addr); + if (off > 127) { + off -= 256; + } + addr += off + 1; + result = '' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + } + break; + case modes.absoluteX: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',X'; + break; + case modes.absoluteY: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',Y'; + break; + case modes.zeroPageX: + result = '' + toHexOrSymbol(this.readByteDebug(addr)) + ',X'; + break; + case modes.zeroPageY: + result = '' + toHexOrSymbol(this.readByteDebug(addr)) + ',Y'; + break; + case modes.absoluteIndirect: + result = '(' + toHexOrSymbol(this.readWordDebug(addr), 4) + ')'; + break; + case modes.zeroPageXIndirect: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + ',X)'; + break; + case modes.zeroPageIndirectY: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + '),Y'; + break; + case modes.accumulator: + result = 'A'; + break; + case modes.zeroPageIndirect: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + ')'; + break; + case modes.absoluteXIndirect: + result = '(' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',X)'; + break; + case modes.zeroPage_relative: + let val = this.readByteDebug(addr); + let off = this.readByteDebug(addr + 1); + if (off > 127) { + off -= 256; + } + addr += off + 2; + result = '' + toHexOrSymbol(val) + ',' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + break; + default: + break; + } + return result; + } + + public step(cb: callback) { + this.sync = true; + let op = this.opary[this.readBytePC()]; + this.sync = false; + op[1](op[2] as any); // TODO(flan): Hack until there is better typing. + + if (cb) { + cb(this); + } + } + + public stepDebug(n: number, cb: callback) { + for (let idx = 0; idx < n; idx++) { + this.sync = true; + let op = this.opary[this.readBytePC()]; + this.sync = false; + op[1](op[2] as any); // TODO(flan): Hack until there is better typing. + + if (cb) { + cb(this); + } + } + } + + public stepCycles(c: number) { + let end = this.cycles + c; + + while (this.cycles < end) { + this.sync = true; + let op = this.opary[this.readBytePC()]; + this.sync = false; + op[1](op[2] as any); // TODO(flan): Hack until there is better typing. + } + } + + public stepCyclesDebug(c: number, cb: callback): void { + var op, end = this.cycles + c; + + while (this.cycles < end) { + this.sync = true; + op = this.opary[this.readBytePC()]; + this.sync = false; + op[1](op[2] as any); // TODO(flan): Hack until there is better typing. + + if (cb) { + cb(this); + } + } + } + + public addPageHandler(pho: (PageHandler | ResettablePageHandler) & (ReadablePage | WriteablePage)) { + for (let idx = pho.start(); idx <= pho.end(); idx++) { + if (isReadablePage(pho)) + this.readPages[idx] = pho; + if (isWriteablePage(pho)) + this.writePages[idx] = pho; + } + if (isResettablePageHandler(pho)) + this.resetHandlers.push(pho); + } + + public reset() { + // cycles = 0; + this.sr = 0x20; + this.sp = 0xff; + this.ar = 0; + this.yr = 0; + this.xr = 0; + this.pc = this.readWord(loc.RESET); + + for (let idx = 0; idx < this.resetHandlers.length; idx++) { + this.resetHandlers[idx].reset(); + } + } + + /* IRQ - Interrupt Request */ + public irq() { + if ((this.sr & flags.I) === 0) { + this.pushWord(this.pc); + this.pushByte(this.sr & ~flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.BRK); + } + } + + /* NMI Non-maskable Interrupt */ + public nmi() { + this.pushWord(this.pc); + this.pushByte(this.sr & ~flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.NMI); + } + + public getPC() { + return this.pc; + } + + public setPC(pc: word) { + this.pc = pc; + } + + public dumpPC(pc: word, symbols: symbols) { + if (pc === undefined) { + pc = this.pc; + } + let b = this.readByte(pc), + op = this.ops[b], + size = sizes[op[3]], + result = toHex(pc, 4) + '- '; + + if (symbols) { + if (symbols[pc]) { + result += symbols[pc] + + ' '.substring(symbols[pc].length); + } else { + result += ' '; + } + } + + for (var idx = 0; idx < 4; idx++) { + if (idx < size) { + result += toHex(this.readByte(pc + idx)) + ' '; + } else { + result += ' '; + } + } + + if (op === undefined) + result += '??? (' + toHex(b) + ')'; + else + result += op[0] + ' ' + this.dumpArgs(pc + 1, op[3], symbols); + + return result; + } + + public dumpPage(start?: word, end?: word) { + var result = ''; + if (start === undefined) { + start = this.pc >> 8; + } + if (end === undefined) { + end = start; + } + for (var page = start; page <= end; page++) { + var b, idx, jdx; + for (idx = 0; idx < 16; idx++) { + result += toHex(page) + toHex(idx << 4) + ': '; + for (jdx = 0; jdx < 16; jdx++) { + b = this.readByteDebug(page * 256 + idx * 16 + jdx); + result += toHex(b) + ' '; + } + result += ' '; + for (jdx = 0; jdx < 16; jdx++) { + b = this.readByte(page * 256 + idx * 16 + jdx) & 0x7f; + if (b >= 0x20 && b < 0x7f) { + result += String.fromCharCode(b); + } else { + result += '.'; + } + } + result += '\n'; + } + } + return result; + } + + public list(_pc: word, symbols: symbols) { + if (_pc === undefined) { + _pc = this.pc; + } + var results = []; + for (var jdx = 0; jdx < 20; jdx++) { + var b = this.readByte(_pc), op = this.ops[b]; + results.push(this.dumpPC(_pc, symbols)); + _pc += sizes[op[3]]; + } + return results; + } + + public sync_() { + return this.sync; + } + + public cycles_() { + return this.cycles; + } + + public registers() { + return [this.pc,this.ar,this.xr,this.yr,this.sr,this.sp]; + } + + public getState(): CpuState { + return { + a: this.ar, + x: this.xr, + y: this.yr, + s: this.sr, + pc: this.pc, + sp: this.sp, + cycles: this.cycles + }; + } + + public setState(state: CpuState) { + this.ar = state.a; + this.xr = state.x; + this.yr = state.y; + this.sr = state.s; + this.pc = state.pc; + this.sp = state.sp; + this.cycles = state.cycles; + } + + public dumpRegisters() { + return toHex(this.pc, 4) + + '- A=' + toHex(this.ar) + + ' X=' + toHex(this.xr) + + ' Y=' + toHex(this.yr) + + ' P=' + toHex(this.sr) + + ' S=' + toHex(this.sp) + + ' ' + + ((this.sr & flags.N) ? 'N' : '-') + + ((this.sr & flags.V) ? 'V' : '-') + + '-' + + ((this.sr & flags.B) ? 'B' : '-') + + ((this.sr & flags.D) ? 'D' : '-') + + ((this.sr & flags.I) ? 'I' : '-') + + ((this.sr & flags.Z) ? 'Z' : '-') + + ((this.sr & flags.C) ? 'C' : '-'); + } + + public read(page: byte, off: byte): byte { + return this.readPages[page].read(page, off); + } + + public write(page: byte, off: byte, val: byte) { + this.writePages[page].write(page, off, val); + } +} + +const c = CPU6502.prototype; +const OPS_6502: Instructions = { + // LDA + 0xa9: ['LDA', c.lda, c.readImmediate, modes.immediate, 2], + 0xa5: ['LDA', c.lda, c.readZeroPage, modes.zeroPage, 3], + 0xb5: ['LDA', c.lda, c.readZeroPageX, modes.zeroPageX, 4], + 0xad: ['LDA', c.lda, c.readAbsolute, modes.absolute, 4], + 0xbd: ['LDA', c.lda, c.readAbsoluteX, modes.absoluteX, 4], + 0xb9: ['LDA', c.lda, c.readAbsoluteY, modes.absoluteY, 4], + 0xa1: ['LDA', c.lda, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xb1: ['LDA', c.lda, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // LDX + 0xa2: ['LDX', c.ldx, c.readImmediate, modes.immediate, 2], + 0xa6: ['LDX', c.ldx, c.readZeroPage, modes.zeroPage, 3], + 0xb6: ['LDX', c.ldx, c.readZeroPageY, modes.zeroPageY, 4], + 0xae: ['LDX', c.ldx, c.readAbsolute, modes.absolute, 4], + 0xbe: ['LDX', c.ldx, c.readAbsoluteY, modes.absoluteY, 4], + + // LDY + 0xa0: ['LDY', c.ldy, c.readImmediate, modes.immediate, 2], + 0xa4: ['LDY', c.ldy, c.readZeroPage, modes.zeroPage, 3], + 0xb4: ['LDY', c.ldy, c.readZeroPageX, modes.zeroPageX, 4], + 0xac: ['LDY', c.ldy, c.readAbsolute, modes.absolute, 4], + 0xbc: ['LDY', c.ldy, c.readAbsoluteX, modes.absoluteX, 4], + + // STA + 0x85: ['STA', c.sta, c.writeZeroPage, modes.zeroPage, 3], + 0x95: ['STA', c.sta, c.writeZeroPageX, modes.zeroPageX, 4], + 0x8d: ['STA', c.sta, c.writeAbsolute, modes.absolute, 4], + 0x9d: ['STA', c.sta, c.writeAbsoluteX, modes.absoluteX, 5], + 0x99: ['STA', c.sta, c.writeAbsoluteY, modes.absoluteY, 5], + 0x81: ['STA', c.sta, c.writeZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x91: ['STA', c.sta, c.writeZeroPageIndirectY, modes.zeroPageIndirectY, 6], + + // STX + 0x86: ['STX', c.stx, c.writeZeroPage, modes.zeroPage, 3], + 0x96: ['STX', c.stx, c.writeZeroPageY, modes.zeroPageY, 4], + 0x8e: ['STX', c.stx, c.writeAbsolute, modes.absolute, 4], + + // STY + 0x84: ['STY', c.sty, c.writeZeroPage, modes.zeroPage, 3], + 0x94: ['STY', c.sty, c.writeZeroPageX, modes.zeroPageX, 4], + 0x8c: ['STY', c.sty, c.writeAbsolute, modes.absolute, 4], + + // ADC + 0x69: ['ADC', c.adc, c.readImmediate, modes.immediate, 2], + 0x65: ['ADC', c.adc, c.readZeroPage, modes.zeroPage, 3], + 0x75: ['ADC', c.adc, c.readZeroPageX, modes.zeroPageX, 4], + 0x6D: ['ADC', c.adc, c.readAbsolute, modes.absolute, 4], + 0x7D: ['ADC', c.adc, c.readAbsoluteX, modes.absoluteX, 4], + 0x79: ['ADC', c.adc, c.readAbsoluteY, modes.absoluteY, 4], + 0x61: ['ADC', c.adc, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x71: ['ADC', c.adc, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // SBC + 0xe9: ['SBC', c.sbc, c.readImmediate, modes.immediate, 2], + 0xe5: ['SBC', c.sbc, c.readZeroPage, modes.zeroPage, 3], + 0xf5: ['SBC', c.sbc, c.readZeroPageX, modes.zeroPageX, 4], + 0xeD: ['SBC', c.sbc, c.readAbsolute, modes.absolute, 4], + 0xfD: ['SBC', c.sbc, c.readAbsoluteX, modes.absoluteX, 4], + 0xf9: ['SBC', c.sbc, c.readAbsoluteY, modes.absoluteY, 4], + 0xe1: ['SBC', c.sbc, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xf1: ['SBC', c.sbc, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // INC + 0xe6: ['INC', c.inc, c.readAddrZeroPage, modes.zeroPage, 5], + 0xf6: ['INC', c.inc, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0xee: ['INC', c.inc, c.readAddrAbsolute, modes.absolute, 6], + 0xfe: ['INC', c.inc, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // INX + 0xe8: ['INX', c.inx, null, modes.implied, 2], + + // INY + 0xc8: ['INY', c.iny, null, modes.implied, 2], + + // DEC + 0xc6: ['DEC', c.dec, c.readAddrZeroPage, modes.zeroPage, 5], + 0xd6: ['DEC', c.dec, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0xce: ['DEC', c.dec, c.readAddrAbsolute, modes.absolute, 6], + 0xde: ['DEC', c.dec, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // DEX + 0xca: ['DEX', c.dex, null, modes.implied, 2], + + // DEY + 0x88: ['DEY', c.dey, null, modes.implied, 2], + + // ASL + 0x0A: ['ASL', c.aslA, null, modes.accumulator, 2], + 0x06: ['ASL', c.asl, c.readAddrZeroPage, modes.zeroPage, 5], + 0x16: ['ASL', c.asl, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x0E: ['ASL', c.asl, c.readAddrAbsolute, modes.absolute, 6], + 0x1E: ['ASL', c.asl, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // LSR + 0x4A: ['LSR', c.lsrA, null, modes.accumulator, 2], + 0x46: ['LSR', c.lsr, c.readAddrZeroPage, modes.zeroPage, 5], + 0x56: ['LSR', c.lsr, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x4E: ['LSR', c.lsr, c.readAddrAbsolute, modes.absolute, 6], + 0x5E: ['LSR', c.lsr, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // ROL + 0x2A: ['ROL', c.rolA, null, modes.accumulator, 2], + 0x26: ['ROL', c.rol, c.readAddrZeroPage, modes.zeroPage, 5], + 0x36: ['ROL', c.rol, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x2E: ['ROL', c.rol, c.readAddrAbsolute, modes.absolute, 6], + 0x3E: ['ROL', c.rol, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // ROR + 0x6A: ['ROR', c.rorA, null, modes.accumulator, 2], + 0x66: ['ROR', c.ror, c.readAddrZeroPage, modes.zeroPage, 5], + 0x76: ['ROR', c.ror, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x6E: ['ROR', c.ror, c.readAddrAbsolute, modes.absolute, 6], + 0x7E: ['ROR', c.ror, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // AND + 0x29: ['AND', c.and, c.readImmediate, modes.immediate, 2], + 0x25: ['AND', c.and, c.readZeroPage, modes.zeroPage, 3], + 0x35: ['AND', c.and, c.readZeroPageX, modes.zeroPageX, 4], + 0x2D: ['AND', c.and, c.readAbsolute, modes.absolute, 4], + 0x3D: ['AND', c.and, c.readAbsoluteX, modes.absoluteX, 4], + 0x39: ['AND', c.and, c.readAbsoluteY, modes.absoluteY, 4], + 0x21: ['AND', c.and, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x31: ['AND', c.and, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // ORA + 0x09: ['ORA', c.ora, c.readImmediate, modes.immediate, 2], + 0x05: ['ORA', c.ora, c.readZeroPage, modes.zeroPage, 3], + 0x15: ['ORA', c.ora, c.readZeroPageX, modes.zeroPageX, 4], + 0x0D: ['ORA', c.ora, c.readAbsolute, modes.absolute, 4], + 0x1D: ['ORA', c.ora, c.readAbsoluteX, modes.absoluteX, 4], + 0x19: ['ORA', c.ora, c.readAbsoluteY, modes.absoluteY, 4], + 0x01: ['ORA', c.ora, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x11: ['ORA', c.ora, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // EOR + 0x49: ['EOR', c.eor, c.readImmediate, modes.immediate, 2], + 0x45: ['EOR', c.eor, c.readZeroPage, modes.zeroPage, 3], + 0x55: ['EOR', c.eor, c.readZeroPageX, modes.zeroPageX, 4], + 0x4D: ['EOR', c.eor, c.readAbsolute, modes.absolute, 4], + 0x5D: ['EOR', c.eor, c.readAbsoluteX, modes.absoluteX, 4], + 0x59: ['EOR', c.eor, c.readAbsoluteY, modes.absoluteY, 4], + 0x41: ['EOR', c.eor, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x51: ['EOR', c.eor, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // CMP + 0xc9: ['CMP', c.cmp, c.readImmediate, modes.immediate, 2], + 0xc5: ['CMP', c.cmp, c.readZeroPage, modes.zeroPage, 3], + 0xd5: ['CMP', c.cmp, c.readZeroPageX, modes.zeroPageX, 4], + 0xcD: ['CMP', c.cmp, c.readAbsolute, modes.absolute, 4], + 0xdD: ['CMP', c.cmp, c.readAbsoluteX, modes.absoluteX, 4], + 0xd9: ['CMP', c.cmp, c.readAbsoluteY, modes.absoluteY, 4], + 0xc1: ['CMP', c.cmp, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xd1: ['CMP', c.cmp, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // CPX + 0xE0: ['CPX', c.cpx, c.readImmediate, modes.immediate, 2], + 0xE4: ['CPX', c.cpx, c.readZeroPage, modes.zeroPage, 3], + 0xEC: ['CPX', c.cpx, c.readAbsolute, modes.absolute, 4], + + // CPY + 0xC0: ['CPY', c.cpy, c.readImmediate, modes.immediate, 2], + 0xC4: ['CPY', c.cpy, c.readZeroPage, modes.zeroPage, 3], + 0xCC: ['CPY', c.cpy, c.readAbsolute, modes.absolute, 4], + + // BIT + 0x24: ['BIT', c.bit, c.readZeroPage, modes.zeroPage, 3], + 0x2C: ['BIT', c.bit, c.readAbsolute, modes.absolute, 4], + + // BCC + 0x90: ['BCC', c.brc, flags.C, modes.relative, 2], + + // BCS + 0xB0: ['BCS', c.brs, flags.C, modes.relative, 2], + + // BEQ + 0xF0: ['BEQ', c.brs, flags.Z, modes.relative, 2], + + // BMI + 0x30: ['BMI', c.brs, flags.N, modes.relative, 2], + + // BNE + 0xD0: ['BNE', c.brc, flags.Z, modes.relative, 2], + + // BPL + 0x10: ['BPL', c.brc, flags.N, modes.relative, 2], + + // BVC + 0x50: ['BVC', c.brc, flags.V, modes.relative, 2], + + // BVS + 0x70: ['BVS', c.brs, flags.V, modes.relative, 2], + + // TAX + 0xAA: ['TAX', c.tax, null, modes.implied, 2], + + // TXA + 0x8A: ['TXA', c.txa, null, modes.implied, 2], + + // TAY + 0xA8: ['TAY', c.tay, null, modes.implied, 2], + + // TYA + 0x98: ['TYA', c.tya, null, modes.implied, 2], + + // TSX + 0xBA: ['TSX', c.tsx, null, modes.implied, 2], + + // TXS + 0x9A: ['TXS', c.txs, null, modes.implied, 2], + + // PHA + 0x48: ['PHA', c.pha, null, modes.implied, 3], + + // PLA + 0x68: ['PLA', c.pla, null, modes.implied, 4], + + // PHP + 0x08: ['PHP', c.php, null, modes.implied, 3], + + // PLP + 0x28: ['PLP', c.plp, null, modes.implied, 4], + + // JMP + 0x4C: [ + 'JMP', c.jmp, c.readAddrAbsolute, modes.absolute, 3 + ], + 0x6C: [ + 'JMP', c.jmp, c.readAddrAbsoluteIndirectBug, modes.absoluteIndirect, 5 + ], + // JSR + 0x20: ['JSR', c.jsr, c.readAddrAbsolute, modes.absolute, 6], + + // RTS + 0x60: ['RTS', c.rts, null, modes.implied, 6], + + // RTI + 0x40: ['RTI', c.rti, null, modes.implied, 6], + + // SEC + 0x38: ['SEC', c.set, flags.C, modes.implied, 2], + + // SED + 0xF8: ['SED', c.set, flags.D, modes.implied, 2], + + // SEI + 0x78: ['SEI', c.set, flags.I, modes.implied, 2], + + // CLC + 0x18: ['CLC', c.clr, flags.C, modes.implied, 2], + + // CLD + 0xD8: ['CLD', c.clr, flags.D, modes.implied, 2], + + // CLI + 0x58: ['CLI', c.clr, flags.I, modes.implied, 2], + + // CLV + 0xB8: ['CLV', c.clr, flags.V, modes.implied, 2], + + // NOP + 0xea: ['NOP', c.nop, c.readImplied, modes.implied, 2], + + // BRK + 0x00: ['BRK', c.brk, c.readImmediate, modes.immediate, 7] +}; + +/* 65C02 Instructions */ + +const OPS_65C02: Instructions = { + // INC / DEC A + 0x1A: ['INC', c.incA, null, modes.accumulator, 2], + 0x3A: ['DEC', c.decA, null, modes.accumulator, 2], + + // Indirect Zero Page for the masses + 0x12: ['ORA', c.ora, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x32: ['AND', c.and, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x52: ['EOR', c.eor, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x72: ['ADC', c.adc, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x92: ['STA', c.sta, c.writeZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xB2: ['LDA', c.lda, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xD2: ['CMP', c.cmp, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xF2: ['SBC', c.sbc, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + + // Better BIT + 0x34: ['BIT', c.bit, c.readZeroPageX, modes.zeroPageX, 4], + 0x3C: ['BIT', c.bit, c.readAbsoluteX, modes.absoluteX, 4], + 0x89: ['BIT', c.bitI, c.readImmediate, modes.immediate, 2], + + // JMP absolute indirect indexed + 0x6C: [ + 'JMP', c.jmp, c.readAddrAbsoluteIndirect, modes.absoluteIndirect, 6 + ], + 0x7C: [ + 'JMP', c.jmp, c.readAddrAbsoluteXIndirect, modes.absoluteXIndirect, 6 + ], + + // BBR/BBS + 0x0F: ['BBR0', c.bbr, 0, modes.zeroPage_relative, 5], + 0x1F: ['BBR1', c.bbr, 1, modes.zeroPage_relative, 5], + 0x2F: ['BBR2', c.bbr, 2, modes.zeroPage_relative, 5], + 0x3F: ['BBR3', c.bbr, 3, modes.zeroPage_relative, 5], + 0x4F: ['BBR4', c.bbr, 4, modes.zeroPage_relative, 5], + 0x5F: ['BBR5', c.bbr, 5, modes.zeroPage_relative, 5], + 0x6F: ['BBR6', c.bbr, 6, modes.zeroPage_relative, 5], + 0x7F: ['BBR7', c.bbr, 7, modes.zeroPage_relative, 5], + + 0x8F: ['BBS0', c.bbs, 0, modes.zeroPage_relative, 5], + 0x9F: ['BBS1', c.bbs, 1, modes.zeroPage_relative, 5], + 0xAF: ['BBS2', c.bbs, 2, modes.zeroPage_relative, 5], + 0xBF: ['BBS3', c.bbs, 3, modes.zeroPage_relative, 5], + 0xCF: ['BBS4', c.bbs, 4, modes.zeroPage_relative, 5], + 0xDF: ['BBS5', c.bbs, 5, modes.zeroPage_relative, 5], + 0xEF: ['BBS6', c.bbs, 6, modes.zeroPage_relative, 5], + 0xFF: ['BBS7', c.bbs, 7, modes.zeroPage_relative, 5], + + // BRA + 0x80: ['BRA', c.brc, 0, modes.relative, 2], + + // NOP + 0x02: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x22: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x42: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x44: ['NOP', c.nop, c.readImmediate, modes.immediate, 3], + 0x54: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0x62: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x82: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xC2: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xD4: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0xE2: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xF4: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0x5C: ['NOP', c.nop, c.readAbsolute, modes.absolute, 8], + 0xDC: ['NOP', c.nop, c.readAbsolute, modes.absolute, 4], + 0xFC: ['NOP', c.nop, c.readAbsolute, modes.absolute, 4], + + // PHX + 0xDA: ['PHX', c.phx, null, modes.implied, 3], + + // PHY + 0x5A: ['PHY', c.phy, null, modes.implied, 3], + + // PLX + 0xFA: ['PLX', c.plx, null, modes.implied, 4], + + // PLY + 0x7A: ['PLY', c.ply, null, modes.implied, 4], + + // RMB/SMB + + 0x07: ['RMB0', c.rmb, 0, modes.zeroPage, 5], + 0x17: ['RMB1', c.rmb, 1, modes.zeroPage, 5], + 0x27: ['RMB2', c.rmb, 2, modes.zeroPage, 5], + 0x37: ['RMB3', c.rmb, 3, modes.zeroPage, 5], + 0x47: ['RMB4', c.rmb, 4, modes.zeroPage, 5], + 0x57: ['RMB5', c.rmb, 5, modes.zeroPage, 5], + 0x67: ['RMB6', c.rmb, 6, modes.zeroPage, 5], + 0x77: ['RMB7', c.rmb, 7, modes.zeroPage, 5], + + 0x87: ['SMB0', c.smb, 0, modes.zeroPage, 5], + 0x97: ['SMB1', c.smb, 1, modes.zeroPage, 5], + 0xA7: ['SMB2', c.smb, 2, modes.zeroPage, 5], + 0xB7: ['SMB3', c.smb, 3, modes.zeroPage, 5], + 0xC7: ['SMB4', c.smb, 4, modes.zeroPage, 5], + 0xD7: ['SMB5', c.smb, 5, modes.zeroPage, 5], + 0xE7: ['SMB6', c.smb, 6, modes.zeroPage, 5], + 0xF7: ['SMB7', c.smb, 7, modes.zeroPage, 5], + + // STZ + 0x64: ['STZ', c.stz, c.writeZeroPage, modes.zeroPage, 3], + 0x74: ['STZ', c.stz, c.writeZeroPageX, modes.zeroPageX, 4], + 0x9C: ['STZ', c.stz, c.writeAbsolute, modes.absolute, 4], + 0x9E: ['STZ', c.stz, c.writeAbsoluteX, modes.absoluteX, 5], + + // TRB + 0x14: ['TRB', c.trb, c.readAddrZeroPage, modes.zeroPage, 5], + 0x1C: ['TRB', c.trb, c.readAddrAbsolute, modes.absolute, 6], + + // TSB + 0x04: ['TSB', c.tsb, c.readAddrZeroPage, modes.zeroPage, 5], + 0x0C: ['TSB', c.tsb, c.readAddrAbsolute, modes.absolute, 6] +}; diff --git a/test/perf/impl/tscpu6502v2.ts b/test/perf/impl/tscpu6502v2.ts new file mode 100644 index 00000000..291fe30d --- /dev/null +++ b/test/perf/impl/tscpu6502v2.ts @@ -0,0 +1,1772 @@ +/* + * Copyright 2010-2019 Will Scullin + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +import { byte, word } from '../../../js/types'; +import { debug, toHex } from '../../../js/util'; + +type symbols = { [key: number]: string }; + +export interface CpuOptions { + '65C02'?: boolean; +} + +export interface CpuState { + a: byte, + x: byte, + y: byte, + s: byte, + pc: word, + sp: byte, + cycles: number +} + +/** Range of mode numbers. */ +type mode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15; + +/** Addressing mode name to number mapping. */ +const modes: { [key: string]: mode } = { + accumulator: 0, // A (Accumulator) + implied: 1, // Implied + immediate: 2, // # Immediate + absolute: 3, // a Absolute + zeroPage: 4, // zp Zero Page + relative: 5, // r Relative + + absoluteX: 6, // a,X Absolute, X + absoluteY: 7, // a,Y Absolute, Y + zeroPageX: 8, // zp,X Zero Page, X + zeroPageY: 9, // zp,Y Zero Page, Y + + absoluteIndirect: 10, // (a) Indirect + zeroPageXIndirect: 11, // (zp,X) Zero Page Indexed Indirect + zeroPageIndirectY: 12, // (zp),Y Zero Page Indexed with Y + + /* 65c02 */ + zeroPageIndirect: 13, // (zp), + absoluteXIndirect: 14, // (a, X), + zeroPage_relative: 15 // zp, Relative +}; + +/** Instruction size by addressing mode. */ +const sizes = { + 0 /* modes.accumulator */: 1, + 1 /* modes.implied */: 1, + 2 /* modes.immediate */: 2, + 3 /* modes.absolute */: 3, + 4 /* modes.zeroPage */: 2, + 5 /* modes.relative */: 2, + 6 /* modes.absoluteX */: 3, + 7 /* modes.absoluteY */: 3, + 8 /* modes.zeroPageX */: 2, + 9 /* modes.zeroPageY */: 2, + 10 /* modes.indirect */: 3, + 11 /* modes.zeroPageXIndirect */: 2, + 12 /* modes.zeroPageYIndirect */: 2, + + 13 /* mode.zeroPageIndirect */: 2, + 14 /* mode.absoluteXIndirect */: 3, + 15 /* mode.zeroPage_relative */: 3 +}; + +/** Status register flag numbers. */ +type flag = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7; + +/** Flags to status byte mask. */ +const flags = { + N: 0x80, // Negative + V: 0x40, // oVerflow + B: 0x10, // Break + D: 0x08, // Decimal + I: 0x04, // Interrupt + Z: 0x02, // Zero + C: 0x01 // Carry +}; + +/** CPU-referenced memory locations. */ +const loc = { + STACK: 0x100, + NMI: 0xFFFA, + RESET: 0xFFFC, + BRK: 0xFFFE +}; + +interface ReadablePage { + read(page: byte, offset: byte): byte; +} + +function isReadablePage(page: ReadablePage | any): page is ReadablePage { + return (page as ReadablePage).read !== undefined; +} + +interface WriteablePage { + write(page: byte, offset: byte, value: byte): void; +} + +function isWriteablePage(page: WriteablePage | any): page is WriteablePage { + return (page as WriteablePage).write !== undefined; +} + +interface PageHandler { + start(): byte; + end(): byte; +} + +function isResettablePageHandler(pageHandler: PageHandler | ResettablePageHandler): pageHandler is ResettablePageHandler { + return (pageHandler as ResettablePageHandler).reset !== undefined; +} + +interface ResettablePageHandler extends PageHandler { + reset(): void; +} + +const BLANK_PAGE: ReadablePage & WriteablePage = { + read: function () { return 0; }, + write: function () { } +}; + +interface Opts { + rwm?: boolean; +} + +type ReadFn = () => byte; +type WriteFn = (val: byte) => void; +type ReadAddrFn = (opts?: Opts) => word; + +type readInstruction = [ + desc: string, + op: (readFn: ReadFn) => void, + modeFn: ReadFn, + mode: mode, // really 0-15 + cycles: number, +]; + +type writeInstruction = [ + desc: string, + op: (writeFn: WriteFn) => void, + modeFn: WriteFn, + mode: mode, // really 0-15 + cycles: number, +]; + +type impliedInstruction = [ + desc: string, + op: () => void, + modeFn: null, + mode: mode, // really 0-15 + cycles: number, +]; + +type relativeInstruction = [ + desc: string, + op: (f: byte) => void, + modeFn: byte, + mode: mode, // really 0-15 + cycles: number, +]; + +type bitInstruction = [ + desc: string, + op: (bit: number) => void, + modeFn: number, + mode: mode, // really 0-15 + cycles: number, +]; + +type noopInstruction = [ + desc: string, + op: (readAddrFn: ReadAddrFn) => void, + modeFn: () => void, + mode: mode, // really 0-15 + cycles: number, +]; + +type instruction = + readInstruction | writeInstruction | + impliedInstruction | relativeInstruction | noopInstruction; + +interface Instructions { + [key: number]: instruction; +} + +type callback = (cpu: any) => void; // TODO(flan): Hack until there is better typing. + +function bind(op: instruction, o: CPU6502): instruction { + let op2: instruction[2] = typeof op[2] === "function" ? op[2].bind(o) : op[2]; + return [op[0], op[1].bind(o), op2, op[3], op[4]]; +} + +export default class CPU6502 { + private readonly is65C02: boolean; + + /* Registers */ + private pc = 0; // Program Counter + private sr = 0x20; // Process Status Register + private ar = 0; // Accumulator + private xr = 0; // X Register + private yr = 0; // Y Register + private sp = 0xff; // Stack Pointer + + private readPages: ReadablePage[] = []; + private writePages: WriteablePage[] = []; + private resetHandlers: ResettablePageHandler[] = []; + private cycles = 0; + private sync = false; + + private readonly ops: Instructions; + private readonly opary: (() => void)[]; + + constructor(options: CpuOptions = {}) { + this.is65C02 = options['65C02'] ? true : false; + + for (let idx = 0; idx < 0x100; idx++) { + this.readPages[idx] = BLANK_PAGE; + this.writePages[idx] = BLANK_PAGE; + } + + // Create this CPU's instruction table + let ops: Instructions = []; + Object.assign(ops, OPS_6502); + if (this.is65C02) { + Object.assign(ops, OPS_65C02); + } + this.ops = ops; + + // Certain browsers benefit from using arrays over maps + let opary: (() => void)[] = []; + + for (let idx = 0; idx < 0x100; idx++) { + if (ops[idx]) { + opary[idx] = () => ops[idx][1].call(this, ops[idx][2] as any) + } else { + opary[idx] = () => this.unknown(idx); + } + } + this.opary = opary; + } + + /** + * Set or clears `f` in the status register. `f` must be a byte with a + * single bit set. + */ + private setFlag(f: byte, on: boolean) { + this.sr = on ? (this.sr | f) : (this.sr & ~f); + } + + /** Updates the status register's zero flag and negative flag. */ + private testNZ(val: byte) { + this.sr = val === 0 ? (this.sr | flags.Z) : (this.sr & ~flags.Z); + this.sr = (val & 0x80) ? (this.sr | flags.N) : (this.sr & ~flags.N); + + return val; + } + + /** Updates the status register's zero flag. */ + private testZ(val: byte) { + this.sr = val === 0 ? (this.sr | flags.Z) : (this.sr & ~flags.Z); + + return val; + } + + /** + * Returns `a + b`, unless `sub` is true, in which case it performs + * `a - b`. The status register is updated according to the result. + */ + private add(a: byte, b: byte, sub: boolean) { + if (sub) + b ^= 0xff; + + // KEGS + var c: number, v: number; + if ((this.sr & flags.D) !== 0) { + // BCD + c = (a & 0x0f) + (b & 0x0f) + (this.sr & flags.C); + if (sub) { + if (c < 0x10) + c = (c - 0x06) & 0x0f; + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c < 0x100) + c = (c + 0xa0) & 0xff; + } else { + if (c > 0x09) + c = (c - 0x0a) | 0x10; // carry to MSN + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c > 0x99) + c += 0x60; + } + } else { + c = a + b + (this.sr & flags.C); + v = (c ^ a) & 0x80; + } + + if (((a ^ b) & 0x80) !== 0) { + v = 0; + } + + this.setFlag(flags.C, c > 0xff); + this.setFlag(flags.V, !!v); + + return this.testNZ(c & 0xff); + } + + /** Increments `a` and returns the value, setting the status register. */ + private increment(a: byte) { + return this.testNZ((a + 0x01) & 0xff); + } + + private decrement(a: byte) { + return this.testNZ((a + 0xff) & 0xff); + } + + private readBytePC(): byte { + let addr = this.pc, + page = addr >> 8, + off = addr & 0xff; + + var result = this.readPages[page].read(page, off); + + this.pc = (this.pc + 1) & 0xffff; + + this.cycles++; + + return result; + } + + private readByte(addr: word): byte { + var page = addr >> 8, + off = addr & 0xff; + + var result = this.readPages[page].read(page, off); + + this.cycles++; + + return result; + } + + private readByteDebug(addr: word) { + var page = addr >> 8, + off = addr & 0xff; + + return this.readPages[page].read(page, off); + } + + private writeByte(addr: word, val: byte) { + var page = addr >> 8, + off = addr & 0xff; + + this.writePages[page].write(page, off, val); + + this.cycles++; + } + + private readWord(addr: word): word { + return this.readByte(addr) | (this.readByte(addr + 1) << 8); + } + + private readWordDebug(addr: word): word { + return this.readByteDebug(addr) | (this.readByteDebug(addr + 1) << 8); + } + + private readWordPC(): word { + return this.readBytePC() | (this.readBytePC() << 8); + } + + private readZPWord(addr: byte): word { + var lsb: number, msb: number; + + lsb = this.readByte(addr & 0xff); + msb = this.readByte((addr + 1) & 0xff); + + return (msb << 8) | lsb; + } + + private pushByte(val: byte) { + this.writeByte(loc.STACK | this.sp, val); + this.sp = (this.sp + 0xff) & 0xff; + } + + private pushWord(val: word) { + this.pushByte(val >> 8); + this.pushByte(val & 0xff); + } + + private pullByte(): byte { + this.sp = (this.sp + 0x01) & 0xff; + return this.readByte(loc.STACK | this.sp); + } + + private pullWordRaw(): word { + var lsb = this.pullByte(); + var msb = this.pullByte(); + + return (msb << 8) | lsb; + } + + /* + * Read functions + */ + + readImplied() { + } + + // #$00 + readImmediate(): byte { + return this.readBytePC(); + } + + // $0000 + readAbsolute(): byte { + return this.readByte(this.readWordPC()); + } + + // $00 + readZeroPage(): byte { + return this.readByte(this.readBytePC()); + } + + // $0000,X + readAbsoluteX(): byte { + var addr = this.readWordPC(); + var oldPage = addr >> 8; + addr = (addr + this.xr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // $0000,Y + readAbsoluteY(): byte { + var addr = this.readWordPC(); + var oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // $00,X + readZeroPageX(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return this.readByte((zpAddr + this.xr) & 0xff); + } + + // $00,Y + readZeroPageY(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return this.readByte((zpAddr + this.yr) & 0xff); + } + + // ($00,X) + readZeroPageXIndirect(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + var addr = this.readZPWord((zpAddr + this.xr) & 0xff); + return this.readByte(addr); + } + + // ($00),Y + readZeroPageIndirectY(): byte { + var addr = this.readZPWord(this.readBytePC()); + var oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // ($00) (65C02) + readZeroPageIndirect(): byte { + return this.readByte(this.readZPWord(this.readBytePC())); + } + + /* + * Write Functions + */ + + // $0000 + writeAbsolute(val: byte) { + this.writeByte(this.readWordPC(), val); + } + + // $00 + writeZeroPage(val: byte) { + this.writeByte(this.readBytePC(), val); + } + + // $0000,X + writeAbsoluteX(val: byte) { + var addr = this.readWordPC(), oldPage = addr >> 8; + addr = (addr + this.xr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // $0000,Y + writeAbsoluteY(val: byte) { + var addr = this.readWordPC(), oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // $00,X + writeZeroPageX(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + this.writeByte((zpAddr + this.xr) & 0xff, val); + } + + // $00,Y + writeZeroPageY(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + this.writeByte((zpAddr + this.yr) & 0xff, val); + } + + // ($00,X) + writeZeroPageXIndirect(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + var addr = this.readZPWord((zpAddr + this.xr) & 0xff); + this.writeByte(addr, val); + } + + // ($00),Y + writeZeroPageIndirectY(val: byte) { + var addr = this.readZPWord(this.readBytePC()), oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // ($00) (65C02) + writeZeroPageIndirect(val: byte) { + this.writeByte(this.readZPWord(this.readBytePC()), val); + } + + // $00 + readAddrZeroPage(): byte { + return this.readBytePC(); + } + + // $00,X + readAddrZeroPageX() { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return (zpAddr + this.xr) & 0xff; + } + + // $0000 (65C02) + readAddrAbsolute(): word { + return this.readWordPC(); + } + + // ($0000) (6502) + readAddrAbsoluteIndirectBug(): word { + var addr = this.readWordPC(); + var page = addr & 0xff00; + var off = addr & 0x00ff; + var lsb = this.readByte(addr); + var msb = this.readByte(page | ((off + 0x01) & 0xff)); + return msb << 8 | lsb; + } + + // ($0000) (65C02) + readAddrAbsoluteIndirect(): word { + var lsb = this.readBytePC(); + var msb = this.readBytePC(); + this.readByte(this.pc); + return this.readWord(msb << 8 | lsb); + } + + // $0000,X + readAddrAbsoluteX(opts: Opts = {}): word { + var addr = this.readWordPC(); + if (!this.is65C02 || opts.rwm) { + this.readByte(addr); + } else { + this.readByte(this.pc); + } + return (addr + this.xr) & 0xffff; + } + + // $(0000,X) (65C02) + readAddrAbsoluteXIndirect(): word { + var address = this.readWordPC(); + this.readByte(this.pc); + return this.readWord((address + this.xr) & 0xffff); + } + + /* Break */ + brk(readFn: ReadFn) { + readFn.call(this); + this.pushWord(this.pc); + this.pushByte(this.sr | flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.BRK); + } + + /* Load Accumulator */ + lda(readFn: ReadFn) { + this.ar = this.testNZ(readFn.call(this)); + } + + /* Load X Register */ + ldx(readFn: ReadFn) { + this.xr = this.testNZ(readFn.call(this)); + } + + /* Load Y Register */ + ldy(readFn: ReadFn) { + this.yr = this.testNZ(readFn.call(this)); + } + + /* Store Accumulator */ + sta(writeFn: WriteFn) { + writeFn.call(this, this.ar); + } + + /* Store X Register */ + stx(writeFn: WriteFn) { + writeFn.call(this, this.xr); + } + + /* Store Y Register */ + sty(writeFn: WriteFn) { + writeFn.call(this, this.yr); + } + + /* Store Zero */ + stz(writeFn: WriteFn) { + writeFn.call(this, 0); + } + + /* Add with Carry */ + adc(readFn: ReadFn) { + this.ar = this.add(this.ar, readFn.call(this), /* sub= */ false); + } + + /* Subtract with Carry */ + sbc(readFn: ReadFn) { + this.ar = this.add(this.ar, readFn.call(this), /* sub= */ true); + } + + /* Increment Memory */ + incA() { + this.readByte(this.pc); + this.ar = this.increment(this.ar); + } + + inc(readAddrFn: ReadAddrFn) { + var addr = readAddrFn.call(this, { rwm: true }); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.increment(oldVal); + this.writeByte(addr, val); + } + + /* Increment X */ + inx() { + this.readByte(this.pc); + this.xr = this.increment(this.xr); + } + + /* Increment Y */ + iny() { + this.readByte(this.pc); + this.yr = this.increment(this.yr); + } + + /* Decrement Memory */ + decA() { + this.readByte(this.pc); + this.ar = this.decrement(this.ar); + } + + dec(readAddrFn: ReadAddrFn) { + var addr = readAddrFn.call(this, { rwm: true }); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.decrement(oldVal); + this.writeByte(addr, val); + } + + /* Decrement X */ + dex() { + this.readByte(this.pc); + this.xr = this.decrement(this.xr); + } + + /* Decrement Y */ + dey() { + this.readByte(this.pc); + this.yr = this.decrement(this.yr); + } + + shiftLeft(val: byte) { + this.setFlag(flags.C, !!(val & 0x80)); + return this.testNZ((val << 1) & 0xff); + } + + /* Arithmetic Shift Left */ + aslA() { + this.readByte(this.pc); + this.ar = this.shiftLeft(this.ar); + } + + asl(readAddrFn: ReadAddrFn) { + var addr = readAddrFn.call(this, { rwm: true }); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.shiftLeft(oldVal); + this.writeByte(addr, val); + } + + shiftRight(val: byte) { + this.setFlag(flags.C, !!(val & 0x01)); + return this.testNZ(val >> 1); + } + + /* Logical Shift Right */ + lsrA() { + this.readByte(this.pc); + this.ar = this.shiftRight(this.ar); + } + + lsr(readAddrFn: ReadAddrFn) { + var addr = readAddrFn.call(this, { rwm: true }); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.shiftRight(oldVal); + this.writeByte(addr, val); + } + + rotateLeft(val: byte) { + var c = (this.sr & flags.C); + this.setFlag(flags.C, !!(val & 0x80)); + return this.testNZ(((val << 1) | (c ? 0x01 : 0x00)) & 0xff); + } + + /* Rotate Left */ + rolA() { + this.readByte(this.pc); + this.ar = this.rotateLeft(this.ar); + } + + rol(readAddrFn: ReadAddrFn) { + var addr = readAddrFn.call(this, { rwm: true }); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.rotateLeft(oldVal); + this.writeByte(addr, val); + } + + private rotateRight(a: byte) { + var c = (this.sr & flags.C); + this.setFlag(flags.C, !!(a & 0x01)); + return this.testNZ((a >> 1) | (c ? 0x80 : 0x00)); + } + + /* Rotate Right */ + rorA() { + this.readByte(this.pc); + this.ar = this.rotateRight(this.ar); + } + + ror(readAddrFn: ReadAddrFn) { + var addr = readAddrFn.call(this, { rwm: true }); + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.rotateRight(oldVal); + this.writeByte(addr, val); + } + + /* Logical And Accumulator */ + and(readFn: ReadFn) { + this.ar = this.testNZ(this.ar & readFn.call(this)); + } + + /* Logical Or Accumulator */ + ora(readFn: ReadFn) { + this.ar = this.testNZ(this.ar | readFn.call(this)); + } + + /* Logical Exclusive Or Accumulator */ + eor(readFn: ReadFn) { + this.ar = this.testNZ(this.ar ^ readFn.call(this)); + } + + /* Reset Bit */ + + rmb(b: byte) { + var bit = (0x1 << b) ^ 0xFF; + var addr = this.readBytePC(); + var val = this.readByte(addr); + this.readByte(addr); + val &= bit; + this.writeByte(addr, val); + } + + /* Set Bit */ + + smb(b: byte) { + var bit = 0x1 << b; + var addr = this.readBytePC(); + var val = this.readByte(addr); + this.readByte(addr); + val |= bit; + this.writeByte(addr, val); + } + + /* Test and Reset Bits */ + trb(readAddrFn: ReadAddrFn) { + var addr = readAddrFn.call(this); + var val = this.readByte(addr); + this.testZ(val & this.ar); + this.readByte(addr); + this.writeByte(addr, val & ~this.ar); + } + + /* Test and Set Bits */ + tsb(readAddrFn: ReadAddrFn) { + var addr = readAddrFn.call(this); + var val = this.readByte(addr); + this.testZ(val & this.ar); + this.readByte(addr); + this.writeByte(addr, val | this.ar); + } + + /* Bit */ + bit(readFn: ReadFn) { + var val = readFn.call(this); + this.setFlag(flags.Z, (val & this.ar) === 0); + this.setFlag(flags.N, !!(val & 0x80)); + this.setFlag(flags.V, !!(val & 0x40)); + } + + /* Bit Immediate*/ + bitI(readFn: ReadFn) { + var val = readFn.call(this); + this.setFlag(flags.Z, (val & this.ar) === 0); + } + + private compare(a: byte, b: byte) { + b = (b ^ 0xff); + var c = a + b + 1; + this.setFlag(flags.C, c > 0xff); + this.testNZ(c & 0xff); + } + + cmp(readFn: ReadFn) { + this.compare(this.ar, readFn.call(this)); + } + + cpx(readFn: ReadFn) { + this.compare(this.xr, readFn.call(this)); + } + + cpy(readFn: ReadFn) { + this.compare(this.yr, readFn.call(this)); + } + + /* Branches */ + brs(f: flag) { + let off = this.readBytePC(); // changes pc + if ((f & this.sr) !== 0) { + this.readByte(this.pc); + let oldPage = this.pc >> 8; + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + let newOff = this.pc & 0xff; + if (newPage != oldPage) this.readByte(oldPage << 8 | newOff); + } + } + + brc(f: flag) { + let off = this.readBytePC(); // changes pc + if ((f & this.sr) === 0) { + this.readByte(this.pc); + let oldPage = this.pc >> 8; + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + let newOff = this.pc & 0xff; + if (newPage != oldPage) this.readByte(oldPage << 8 | newOff); + } + } + + /* WDC 65C02 branches */ + + bbr(b: flag) { + let zpAddr = this.readBytePC(); + let val = this.readByte(zpAddr); + this.readByte(zpAddr); + let off = this.readBytePC(); // changes pc + + if (((1 << b) & val) === 0) { + let oldPc = this.pc; + let oldPage = oldPc >> 8; + this.readByte(oldPc); + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + if (oldPage != newPage) { + this.readByte(oldPc); + } + } + } + + bbs(b: flag) { + let zpAddr = this.readBytePC(); + let val = this.readByte(zpAddr); + this.readByte(zpAddr); + let off = this.readBytePC(); // changes pc + + if (((1 << b) & val) !== 0) { + let oldPc = this.pc; + let oldPage = oldPc >> 8; + this.readByte(oldPc); + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + if (oldPage != newPage) { + this.readByte(oldPc); + } + } + } + + /* Transfers and stack */ + tax() { this.readByte(this.pc); this.testNZ(this.xr = this.ar); } + + txa() { this.readByte(this.pc); this.testNZ(this.ar = this.xr); } + + tay() { this.readByte(this.pc); this.testNZ(this.yr = this.ar); } + + tya() { this.readByte(this.pc); this.testNZ(this.ar = this.yr); } + + tsx() { this.readByte(this.pc); this.testNZ(this.xr = this.sp); } + + txs() { this.readByte(this.pc); this.sp = this.xr; } + + pha() { this.readByte(this.pc); this.pushByte(this.ar); } + + pla() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.ar = this.pullByte()); } + + phx() { this.readByte(this.pc); this.pushByte(this.xr); } + + plx() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.xr = this.pullByte()); } + + phy() { this.readByte(this.pc); this.pushByte(this.yr); } + + ply() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.yr = this.pullByte()); } + + php() { this.readByte(this.pc); this.pushByte(this.sr | flags.B); } + + plp() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.sr = (this.pullByte() & ~flags.B) | 0x20; } + + /* Jump */ + jmp(readAddrFn: ReadAddrFn) { + this.pc = readAddrFn.call(this); + } + + /* Jump Subroutine */ + jsr() { + let lsb = this.readBytePC(); + this.readByte(0x0100 | this.sp); + this.pushWord(this.pc); + let msb = this.readBytePC(); + this.pc = (msb << 8 | lsb) & 0xffff; + } + + /* Return from Subroutine */ + rts() { + this.readByte(this.pc); + this.readByte(0x0100 | this.sp); + let addr = this.pullWordRaw(); + this.readByte(addr); + this.pc = (addr + 1) & 0xffff; + } + + /* Return from Interrupt */ + rti() { + this.readByte(this.pc); + this.readByte(0x0100 | this.sp); + this.sr = this.pullByte() & ~flags.B; + this.pc = this.pullWordRaw(); + } + + /* Set and Clear */ + set(flag: flag) { + this.readByte(this.pc); + this.sr |= flag; + } + + clr(flag: flag) { + this.readByte(this.pc); + this.sr &= ~flag; + } + + /* No-Op */ + nop(readAddrFn: ReadAddrFn) { + this.readByte(this.pc); + readAddrFn.call(this); + } + + private unknown(b: byte) { + let unk: noopInstruction; + + if (this.is65C02) { + unk = [ + 'NOP', + this.nop, + this.readImplied, + modes.implied, + 2 + ]; + } else { + unk = [ + '???', + function () { + debug('Unknown OpCode: ' + toHex(b) + + ' at ' + toHex(this.pc - 1, 4)); + }, + this.readImplied, + modes.implied, + 1 + ]; + } + this.ops[b] = unk; + return unk; + } + + private dumpArgs(addr: word, m: mode, symbols: symbols) { + function toHexOrSymbol(v: word, n?: number) { + if (symbols && symbols[v]) { + return symbols[v]; + } else { + return '$' + toHex(v, n); + } + } + + let result = ''; + switch (m) { + case modes.implied: + break; + case modes.immediate: + result = '#' + toHexOrSymbol(this.readByteDebug(addr)); + break; + case modes.absolute: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4); + break; + case modes.zeroPage: + result = '' + toHexOrSymbol(this.readByteDebug(addr)); + break; + case modes.relative: + { + let off = this.readByteDebug(addr); + if (off > 127) { + off -= 256; + } + addr += off + 1; + result = '' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + } + break; + case modes.absoluteX: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',X'; + break; + case modes.absoluteY: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',Y'; + break; + case modes.zeroPageX: + result = '' + toHexOrSymbol(this.readByteDebug(addr)) + ',X'; + break; + case modes.zeroPageY: + result = '' + toHexOrSymbol(this.readByteDebug(addr)) + ',Y'; + break; + case modes.absoluteIndirect: + result = '(' + toHexOrSymbol(this.readWordDebug(addr), 4) + ')'; + break; + case modes.zeroPageXIndirect: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + ',X)'; + break; + case modes.zeroPageIndirectY: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + '),Y'; + break; + case modes.accumulator: + result = 'A'; + break; + case modes.zeroPageIndirect: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + ')'; + break; + case modes.absoluteXIndirect: + result = '(' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',X)'; + break; + case modes.zeroPage_relative: + let val = this.readByteDebug(addr); + let off = this.readByteDebug(addr + 1); + if (off > 127) { + off -= 256; + } + addr += off + 2; + result = '' + toHexOrSymbol(val) + ',' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + break; + default: + break; + } + return result; + } + + public step(cb: callback) { + this.sync = true; + let op = this.opary[this.readBytePC()]; + this.sync = false; + op(); + + if (cb) { + cb(this); + } + } + + public stepDebug(n: number, cb: callback) { + for (let idx = 0; idx < n; idx++) { + this.sync = true; + let op = this.opary[this.readBytePC()]; + this.sync = false; + op(); + + if (cb) { + cb(this); + } + } + } + + public stepCycles(c: number) { + let end = this.cycles + c; + + while (this.cycles < end) { + this.sync = true; + let op = this.opary[this.readBytePC()]; + this.sync = false; + op(); + } + } + + public stepCyclesDebug(c: number, cb: callback): void { + let op: () => void; + let end = this.cycles + c; + + while (this.cycles < end) { + this.sync = true; + op = this.opary[this.readBytePC()]; + this.sync = false; + op(); + + if (cb) { + cb(this); + } + } + } + + public addPageHandler(pho: (PageHandler | ResettablePageHandler) & (ReadablePage | WriteablePage)) { + for (let idx = pho.start(); idx <= pho.end(); idx++) { + if (isReadablePage(pho)) + this.readPages[idx] = pho; + if (isWriteablePage(pho)) + this.writePages[idx] = pho; + } + if (isResettablePageHandler(pho)) + this.resetHandlers.push(pho); + } + + public reset() { + // cycles = 0; + this.sr = 0x20; + this.sp = 0xff; + this.ar = 0; + this.yr = 0; + this.xr = 0; + this.pc = this.readWord(loc.RESET); + + for (let idx = 0; idx < this.resetHandlers.length; idx++) { + this.resetHandlers[idx].reset(); + } + } + + /* IRQ - Interrupt Request */ + public irq() { + if ((this.sr & flags.I) === 0) { + this.pushWord(this.pc); + this.pushByte(this.sr & ~flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.BRK); + } + } + + /* NMI Non-maskable Interrupt */ + public nmi() { + this.pushWord(this.pc); + this.pushByte(this.sr & ~flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.NMI); + } + + public getPC() { + return this.pc; + } + + public setPC(pc: word) { + this.pc = pc; + } + + public dumpPC(pc: word, symbols: symbols) { + if (pc === undefined) { + pc = this.pc; + } + let b = this.readByte(pc), + op = this.ops[b], + size = sizes[op[3]], + result = toHex(pc, 4) + '- '; + + if (symbols) { + if (symbols[pc]) { + result += symbols[pc] + + ' '.substring(symbols[pc].length); + } else { + result += ' '; + } + } + + for (var idx = 0; idx < 4; idx++) { + if (idx < size) { + result += toHex(this.readByte(pc + idx)) + ' '; + } else { + result += ' '; + } + } + + if (op === undefined) + result += '??? (' + toHex(b) + ')'; + else + result += op[0] + ' ' + this.dumpArgs(pc + 1, op[3], symbols); + + return result; + } + + public dumpPage(start?: word, end?: word) { + var result = ''; + if (start === undefined) { + start = this.pc >> 8; + } + if (end === undefined) { + end = start; + } + for (var page = start; page <= end; page++) { + var b: number, idx: number, jdx: number; + for (idx = 0; idx < 16; idx++) { + result += toHex(page) + toHex(idx << 4) + ': '; + for (jdx = 0; jdx < 16; jdx++) { + b = this.readByteDebug(page * 256 + idx * 16 + jdx); + result += toHex(b) + ' '; + } + result += ' '; + for (jdx = 0; jdx < 16; jdx++) { + b = this.readByte(page * 256 + idx * 16 + jdx) & 0x7f; + if (b >= 0x20 && b < 0x7f) { + result += String.fromCharCode(b); + } else { + result += '.'; + } + } + result += '\n'; + } + } + return result; + } + + public list(_pc: word, symbols: symbols) { + if (_pc === undefined) { + _pc = this.pc; + } + var results = []; + for (var jdx = 0; jdx < 20; jdx++) { + var b = this.readByte(_pc), op = this.ops[b]; + results.push(this.dumpPC(_pc, symbols)); + _pc += sizes[op[3]]; + } + return results; + } + + public sync_() { + return this.sync; + } + + public cycles_() { + return this.cycles; + } + + public registers() { + return [this.pc, this.ar, this.xr, this.yr, this.sr, this.sp]; + } + + public getState(): CpuState { + return { + a: this.ar, + x: this.xr, + y: this.yr, + s: this.sr, + pc: this.pc, + sp: this.sp, + cycles: this.cycles + }; + } + + public setState(state: CpuState) { + this.ar = state.a; + this.xr = state.x; + this.yr = state.y; + this.sr = state.s; + this.pc = state.pc; + this.sp = state.sp; + this.cycles = state.cycles; + } + + public dumpRegisters() { + return toHex(this.pc, 4) + + '- A=' + toHex(this.ar) + + ' X=' + toHex(this.xr) + + ' Y=' + toHex(this.yr) + + ' P=' + toHex(this.sr) + + ' S=' + toHex(this.sp) + + ' ' + + ((this.sr & flags.N) ? 'N' : '-') + + ((this.sr & flags.V) ? 'V' : '-') + + '-' + + ((this.sr & flags.B) ? 'B' : '-') + + ((this.sr & flags.D) ? 'D' : '-') + + ((this.sr & flags.I) ? 'I' : '-') + + ((this.sr & flags.Z) ? 'Z' : '-') + + ((this.sr & flags.C) ? 'C' : '-'); + } + + public read(page: byte, off: byte): byte { + return this.readPages[page].read(page, off); + } + + public write(page: byte, off: byte, val: byte) { + this.writePages[page].write(page, off, val); + } +} + +const c = CPU6502.prototype; +const OPS_6502: Instructions = { + // LDA + 0xa9: ['LDA', c.lda, c.readImmediate, modes.immediate, 2], + 0xa5: ['LDA', c.lda, c.readZeroPage, modes.zeroPage, 3], + 0xb5: ['LDA', c.lda, c.readZeroPageX, modes.zeroPageX, 4], + 0xad: ['LDA', c.lda, c.readAbsolute, modes.absolute, 4], + 0xbd: ['LDA', c.lda, c.readAbsoluteX, modes.absoluteX, 4], + 0xb9: ['LDA', c.lda, c.readAbsoluteY, modes.absoluteY, 4], + 0xa1: ['LDA', c.lda, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xb1: ['LDA', c.lda, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // LDX + 0xa2: ['LDX', c.ldx, c.readImmediate, modes.immediate, 2], + 0xa6: ['LDX', c.ldx, c.readZeroPage, modes.zeroPage, 3], + 0xb6: ['LDX', c.ldx, c.readZeroPageY, modes.zeroPageY, 4], + 0xae: ['LDX', c.ldx, c.readAbsolute, modes.absolute, 4], + 0xbe: ['LDX', c.ldx, c.readAbsoluteY, modes.absoluteY, 4], + + // LDY + 0xa0: ['LDY', c.ldy, c.readImmediate, modes.immediate, 2], + 0xa4: ['LDY', c.ldy, c.readZeroPage, modes.zeroPage, 3], + 0xb4: ['LDY', c.ldy, c.readZeroPageX, modes.zeroPageX, 4], + 0xac: ['LDY', c.ldy, c.readAbsolute, modes.absolute, 4], + 0xbc: ['LDY', c.ldy, c.readAbsoluteX, modes.absoluteX, 4], + + // STA + 0x85: ['STA', c.sta, c.writeZeroPage, modes.zeroPage, 3], + 0x95: ['STA', c.sta, c.writeZeroPageX, modes.zeroPageX, 4], + 0x8d: ['STA', c.sta, c.writeAbsolute, modes.absolute, 4], + 0x9d: ['STA', c.sta, c.writeAbsoluteX, modes.absoluteX, 5], + 0x99: ['STA', c.sta, c.writeAbsoluteY, modes.absoluteY, 5], + 0x81: ['STA', c.sta, c.writeZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x91: ['STA', c.sta, c.writeZeroPageIndirectY, modes.zeroPageIndirectY, 6], + + // STX + 0x86: ['STX', c.stx, c.writeZeroPage, modes.zeroPage, 3], + 0x96: ['STX', c.stx, c.writeZeroPageY, modes.zeroPageY, 4], + 0x8e: ['STX', c.stx, c.writeAbsolute, modes.absolute, 4], + + // STY + 0x84: ['STY', c.sty, c.writeZeroPage, modes.zeroPage, 3], + 0x94: ['STY', c.sty, c.writeZeroPageX, modes.zeroPageX, 4], + 0x8c: ['STY', c.sty, c.writeAbsolute, modes.absolute, 4], + + // ADC + 0x69: ['ADC', c.adc, c.readImmediate, modes.immediate, 2], + 0x65: ['ADC', c.adc, c.readZeroPage, modes.zeroPage, 3], + 0x75: ['ADC', c.adc, c.readZeroPageX, modes.zeroPageX, 4], + 0x6D: ['ADC', c.adc, c.readAbsolute, modes.absolute, 4], + 0x7D: ['ADC', c.adc, c.readAbsoluteX, modes.absoluteX, 4], + 0x79: ['ADC', c.adc, c.readAbsoluteY, modes.absoluteY, 4], + 0x61: ['ADC', c.adc, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x71: ['ADC', c.adc, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // SBC + 0xe9: ['SBC', c.sbc, c.readImmediate, modes.immediate, 2], + 0xe5: ['SBC', c.sbc, c.readZeroPage, modes.zeroPage, 3], + 0xf5: ['SBC', c.sbc, c.readZeroPageX, modes.zeroPageX, 4], + 0xeD: ['SBC', c.sbc, c.readAbsolute, modes.absolute, 4], + 0xfD: ['SBC', c.sbc, c.readAbsoluteX, modes.absoluteX, 4], + 0xf9: ['SBC', c.sbc, c.readAbsoluteY, modes.absoluteY, 4], + 0xe1: ['SBC', c.sbc, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xf1: ['SBC', c.sbc, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // INC + 0xe6: ['INC', c.inc, c.readAddrZeroPage, modes.zeroPage, 5], + 0xf6: ['INC', c.inc, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0xee: ['INC', c.inc, c.readAddrAbsolute, modes.absolute, 6], + 0xfe: ['INC', c.inc, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // INX + 0xe8: ['INX', c.inx, null, modes.implied, 2], + + // INY + 0xc8: ['INY', c.iny, null, modes.implied, 2], + + // DEC + 0xc6: ['DEC', c.dec, c.readAddrZeroPage, modes.zeroPage, 5], + 0xd6: ['DEC', c.dec, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0xce: ['DEC', c.dec, c.readAddrAbsolute, modes.absolute, 6], + 0xde: ['DEC', c.dec, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // DEX + 0xca: ['DEX', c.dex, null, modes.implied, 2], + + // DEY + 0x88: ['DEY', c.dey, null, modes.implied, 2], + + // ASL + 0x0A: ['ASL', c.aslA, null, modes.accumulator, 2], + 0x06: ['ASL', c.asl, c.readAddrZeroPage, modes.zeroPage, 5], + 0x16: ['ASL', c.asl, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x0E: ['ASL', c.asl, c.readAddrAbsolute, modes.absolute, 6], + 0x1E: ['ASL', c.asl, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // LSR + 0x4A: ['LSR', c.lsrA, null, modes.accumulator, 2], + 0x46: ['LSR', c.lsr, c.readAddrZeroPage, modes.zeroPage, 5], + 0x56: ['LSR', c.lsr, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x4E: ['LSR', c.lsr, c.readAddrAbsolute, modes.absolute, 6], + 0x5E: ['LSR', c.lsr, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // ROL + 0x2A: ['ROL', c.rolA, null, modes.accumulator, 2], + 0x26: ['ROL', c.rol, c.readAddrZeroPage, modes.zeroPage, 5], + 0x36: ['ROL', c.rol, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x2E: ['ROL', c.rol, c.readAddrAbsolute, modes.absolute, 6], + 0x3E: ['ROL', c.rol, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // ROR + 0x6A: ['ROR', c.rorA, null, modes.accumulator, 2], + 0x66: ['ROR', c.ror, c.readAddrZeroPage, modes.zeroPage, 5], + 0x76: ['ROR', c.ror, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x6E: ['ROR', c.ror, c.readAddrAbsolute, modes.absolute, 6], + 0x7E: ['ROR', c.ror, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // AND + 0x29: ['AND', c.and, c.readImmediate, modes.immediate, 2], + 0x25: ['AND', c.and, c.readZeroPage, modes.zeroPage, 3], + 0x35: ['AND', c.and, c.readZeroPageX, modes.zeroPageX, 4], + 0x2D: ['AND', c.and, c.readAbsolute, modes.absolute, 4], + 0x3D: ['AND', c.and, c.readAbsoluteX, modes.absoluteX, 4], + 0x39: ['AND', c.and, c.readAbsoluteY, modes.absoluteY, 4], + 0x21: ['AND', c.and, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x31: ['AND', c.and, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // ORA + 0x09: ['ORA', c.ora, c.readImmediate, modes.immediate, 2], + 0x05: ['ORA', c.ora, c.readZeroPage, modes.zeroPage, 3], + 0x15: ['ORA', c.ora, c.readZeroPageX, modes.zeroPageX, 4], + 0x0D: ['ORA', c.ora, c.readAbsolute, modes.absolute, 4], + 0x1D: ['ORA', c.ora, c.readAbsoluteX, modes.absoluteX, 4], + 0x19: ['ORA', c.ora, c.readAbsoluteY, modes.absoluteY, 4], + 0x01: ['ORA', c.ora, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x11: ['ORA', c.ora, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // EOR + 0x49: ['EOR', c.eor, c.readImmediate, modes.immediate, 2], + 0x45: ['EOR', c.eor, c.readZeroPage, modes.zeroPage, 3], + 0x55: ['EOR', c.eor, c.readZeroPageX, modes.zeroPageX, 4], + 0x4D: ['EOR', c.eor, c.readAbsolute, modes.absolute, 4], + 0x5D: ['EOR', c.eor, c.readAbsoluteX, modes.absoluteX, 4], + 0x59: ['EOR', c.eor, c.readAbsoluteY, modes.absoluteY, 4], + 0x41: ['EOR', c.eor, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x51: ['EOR', c.eor, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // CMP + 0xc9: ['CMP', c.cmp, c.readImmediate, modes.immediate, 2], + 0xc5: ['CMP', c.cmp, c.readZeroPage, modes.zeroPage, 3], + 0xd5: ['CMP', c.cmp, c.readZeroPageX, modes.zeroPageX, 4], + 0xcD: ['CMP', c.cmp, c.readAbsolute, modes.absolute, 4], + 0xdD: ['CMP', c.cmp, c.readAbsoluteX, modes.absoluteX, 4], + 0xd9: ['CMP', c.cmp, c.readAbsoluteY, modes.absoluteY, 4], + 0xc1: ['CMP', c.cmp, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xd1: ['CMP', c.cmp, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // CPX + 0xE0: ['CPX', c.cpx, c.readImmediate, modes.immediate, 2], + 0xE4: ['CPX', c.cpx, c.readZeroPage, modes.zeroPage, 3], + 0xEC: ['CPX', c.cpx, c.readAbsolute, modes.absolute, 4], + + // CPY + 0xC0: ['CPY', c.cpy, c.readImmediate, modes.immediate, 2], + 0xC4: ['CPY', c.cpy, c.readZeroPage, modes.zeroPage, 3], + 0xCC: ['CPY', c.cpy, c.readAbsolute, modes.absolute, 4], + + // BIT + 0x24: ['BIT', c.bit, c.readZeroPage, modes.zeroPage, 3], + 0x2C: ['BIT', c.bit, c.readAbsolute, modes.absolute, 4], + + // BCC + 0x90: ['BCC', c.brc, flags.C, modes.relative, 2], + + // BCS + 0xB0: ['BCS', c.brs, flags.C, modes.relative, 2], + + // BEQ + 0xF0: ['BEQ', c.brs, flags.Z, modes.relative, 2], + + // BMI + 0x30: ['BMI', c.brs, flags.N, modes.relative, 2], + + // BNE + 0xD0: ['BNE', c.brc, flags.Z, modes.relative, 2], + + // BPL + 0x10: ['BPL', c.brc, flags.N, modes.relative, 2], + + // BVC + 0x50: ['BVC', c.brc, flags.V, modes.relative, 2], + + // BVS + 0x70: ['BVS', c.brs, flags.V, modes.relative, 2], + + // TAX + 0xAA: ['TAX', c.tax, null, modes.implied, 2], + + // TXA + 0x8A: ['TXA', c.txa, null, modes.implied, 2], + + // TAY + 0xA8: ['TAY', c.tay, null, modes.implied, 2], + + // TYA + 0x98: ['TYA', c.tya, null, modes.implied, 2], + + // TSX + 0xBA: ['TSX', c.tsx, null, modes.implied, 2], + + // TXS + 0x9A: ['TXS', c.txs, null, modes.implied, 2], + + // PHA + 0x48: ['PHA', c.pha, null, modes.implied, 3], + + // PLA + 0x68: ['PLA', c.pla, null, modes.implied, 4], + + // PHP + 0x08: ['PHP', c.php, null, modes.implied, 3], + + // PLP + 0x28: ['PLP', c.plp, null, modes.implied, 4], + + // JMP + 0x4C: [ + 'JMP', c.jmp, c.readAddrAbsolute, modes.absolute, 3 + ], + 0x6C: [ + 'JMP', c.jmp, c.readAddrAbsoluteIndirectBug, modes.absoluteIndirect, 5 + ], + // JSR + 0x20: ['JSR', c.jsr, c.readAddrAbsolute, modes.absolute, 6], + + // RTS + 0x60: ['RTS', c.rts, null, modes.implied, 6], + + // RTI + 0x40: ['RTI', c.rti, null, modes.implied, 6], + + // SEC + 0x38: ['SEC', c.set, flags.C, modes.implied, 2], + + // SED + 0xF8: ['SED', c.set, flags.D, modes.implied, 2], + + // SEI + 0x78: ['SEI', c.set, flags.I, modes.implied, 2], + + // CLC + 0x18: ['CLC', c.clr, flags.C, modes.implied, 2], + + // CLD + 0xD8: ['CLD', c.clr, flags.D, modes.implied, 2], + + // CLI + 0x58: ['CLI', c.clr, flags.I, modes.implied, 2], + + // CLV + 0xB8: ['CLV', c.clr, flags.V, modes.implied, 2], + + // NOP + 0xea: ['NOP', c.nop, c.readImplied, modes.implied, 2], + + // BRK + 0x00: ['BRK', c.brk, c.readImmediate, modes.immediate, 7] +}; + +/* 65C02 Instructions */ + +const OPS_65C02: Instructions = { + // INC / DEC A + 0x1A: ['INC', c.incA, null, modes.accumulator, 2], + 0x3A: ['DEC', c.decA, null, modes.accumulator, 2], + + // Indirect Zero Page for the masses + 0x12: ['ORA', c.ora, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x32: ['AND', c.and, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x52: ['EOR', c.eor, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x72: ['ADC', c.adc, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x92: ['STA', c.sta, c.writeZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xB2: ['LDA', c.lda, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xD2: ['CMP', c.cmp, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xF2: ['SBC', c.sbc, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + + // Better BIT + 0x34: ['BIT', c.bit, c.readZeroPageX, modes.zeroPageX, 4], + 0x3C: ['BIT', c.bit, c.readAbsoluteX, modes.absoluteX, 4], + 0x89: ['BIT', c.bitI, c.readImmediate, modes.immediate, 2], + + // JMP absolute indirect indexed + 0x6C: [ + 'JMP', c.jmp, c.readAddrAbsoluteIndirect, modes.absoluteIndirect, 6 + ], + 0x7C: [ + 'JMP', c.jmp, c.readAddrAbsoluteXIndirect, modes.absoluteXIndirect, 6 + ], + + // BBR/BBS + 0x0F: ['BBR0', c.bbr, 0, modes.zeroPage_relative, 5], + 0x1F: ['BBR1', c.bbr, 1, modes.zeroPage_relative, 5], + 0x2F: ['BBR2', c.bbr, 2, modes.zeroPage_relative, 5], + 0x3F: ['BBR3', c.bbr, 3, modes.zeroPage_relative, 5], + 0x4F: ['BBR4', c.bbr, 4, modes.zeroPage_relative, 5], + 0x5F: ['BBR5', c.bbr, 5, modes.zeroPage_relative, 5], + 0x6F: ['BBR6', c.bbr, 6, modes.zeroPage_relative, 5], + 0x7F: ['BBR7', c.bbr, 7, modes.zeroPage_relative, 5], + + 0x8F: ['BBS0', c.bbs, 0, modes.zeroPage_relative, 5], + 0x9F: ['BBS1', c.bbs, 1, modes.zeroPage_relative, 5], + 0xAF: ['BBS2', c.bbs, 2, modes.zeroPage_relative, 5], + 0xBF: ['BBS3', c.bbs, 3, modes.zeroPage_relative, 5], + 0xCF: ['BBS4', c.bbs, 4, modes.zeroPage_relative, 5], + 0xDF: ['BBS5', c.bbs, 5, modes.zeroPage_relative, 5], + 0xEF: ['BBS6', c.bbs, 6, modes.zeroPage_relative, 5], + 0xFF: ['BBS7', c.bbs, 7, modes.zeroPage_relative, 5], + + // BRA + 0x80: ['BRA', c.brc, 0, modes.relative, 2], + + // NOP + 0x02: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x22: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x42: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x44: ['NOP', c.nop, c.readImmediate, modes.immediate, 3], + 0x54: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0x62: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x82: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xC2: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xD4: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0xE2: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xF4: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0x5C: ['NOP', c.nop, c.readAbsolute, modes.absolute, 8], + 0xDC: ['NOP', c.nop, c.readAbsolute, modes.absolute, 4], + 0xFC: ['NOP', c.nop, c.readAbsolute, modes.absolute, 4], + + // PHX + 0xDA: ['PHX', c.phx, null, modes.implied, 3], + + // PHY + 0x5A: ['PHY', c.phy, null, modes.implied, 3], + + // PLX + 0xFA: ['PLX', c.plx, null, modes.implied, 4], + + // PLY + 0x7A: ['PLY', c.ply, null, modes.implied, 4], + + // RMB/SMB + + 0x07: ['RMB0', c.rmb, 0, modes.zeroPage, 5], + 0x17: ['RMB1', c.rmb, 1, modes.zeroPage, 5], + 0x27: ['RMB2', c.rmb, 2, modes.zeroPage, 5], + 0x37: ['RMB3', c.rmb, 3, modes.zeroPage, 5], + 0x47: ['RMB4', c.rmb, 4, modes.zeroPage, 5], + 0x57: ['RMB5', c.rmb, 5, modes.zeroPage, 5], + 0x67: ['RMB6', c.rmb, 6, modes.zeroPage, 5], + 0x77: ['RMB7', c.rmb, 7, modes.zeroPage, 5], + + 0x87: ['SMB0', c.smb, 0, modes.zeroPage, 5], + 0x97: ['SMB1', c.smb, 1, modes.zeroPage, 5], + 0xA7: ['SMB2', c.smb, 2, modes.zeroPage, 5], + 0xB7: ['SMB3', c.smb, 3, modes.zeroPage, 5], + 0xC7: ['SMB4', c.smb, 4, modes.zeroPage, 5], + 0xD7: ['SMB5', c.smb, 5, modes.zeroPage, 5], + 0xE7: ['SMB6', c.smb, 6, modes.zeroPage, 5], + 0xF7: ['SMB7', c.smb, 7, modes.zeroPage, 5], + + // STZ + 0x64: ['STZ', c.stz, c.writeZeroPage, modes.zeroPage, 3], + 0x74: ['STZ', c.stz, c.writeZeroPageX, modes.zeroPageX, 4], + 0x9C: ['STZ', c.stz, c.writeAbsolute, modes.absolute, 4], + 0x9E: ['STZ', c.stz, c.writeAbsoluteX, modes.absoluteX, 5], + + // TRB + 0x14: ['TRB', c.trb, c.readAddrZeroPage, modes.zeroPage, 5], + 0x1C: ['TRB', c.trb, c.readAddrAbsolute, modes.absolute, 6], + + // TSB + 0x04: ['TSB', c.tsb, c.readAddrZeroPage, modes.zeroPage, 5], + 0x0C: ['TSB', c.tsb, c.readAddrAbsolute, modes.absolute, 6] +}; diff --git a/test/perf/impl/tscpu6502v5.ts b/test/perf/impl/tscpu6502v5.ts new file mode 100644 index 00000000..353f600e --- /dev/null +++ b/test/perf/impl/tscpu6502v5.ts @@ -0,0 +1,1979 @@ +/* + * Copyright 2010-2019 Will Scullin + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +import { byte, word } from '../../../js/types'; +import { debug, toHex } from '../../../js/util'; + +type symbols = { [key: number]: string }; + +export interface CpuOptions { + '65C02'?: boolean; +} + +export interface CpuState { + a: byte, + x: byte, + y: byte, + s: byte, + pc: word, + sp: byte, + cycles: number +} + +/** Range of mode numbers. */ +type mode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15; + +/** Addressing mode name to number mapping. */ +const modes: { [key: string]: mode } = { + accumulator: 0, // A (Accumulator) + implied: 1, // Implied + immediate: 2, // # Immediate + absolute: 3, // a Absolute + zeroPage: 4, // zp Zero Page + relative: 5, // r Relative + + absoluteX: 6, // a,X Absolute, X + absoluteY: 7, // a,Y Absolute, Y + zeroPageX: 8, // zp,X Zero Page, X + zeroPageY: 9, // zp,Y Zero Page, Y + + absoluteIndirect: 10, // (a) Indirect + zeroPageXIndirect: 11, // (zp,X) Zero Page Indexed Indirect + zeroPageIndirectY: 12, // (zp),Y Zero Page Indexed with Y + + /* 65c02 */ + zeroPageIndirect: 13, // (zp), + absoluteXIndirect: 14, // (a, X), + zeroPage_relative: 15 // zp, Relative +}; + +/** Instruction size by addressing mode. */ +const sizes = { + 0 /* modes.accumulator */: 1, + 1 /* modes.implied */: 1, + 2 /* modes.immediate */: 2, + 3 /* modes.absolute */: 3, + 4 /* modes.zeroPage */: 2, + 5 /* modes.relative */: 2, + 6 /* modes.absoluteX */: 3, + 7 /* modes.absoluteY */: 3, + 8 /* modes.zeroPageX */: 2, + 9 /* modes.zeroPageY */: 2, + 10 /* modes.indirect */: 3, + 11 /* modes.zeroPageXIndirect */: 2, + 12 /* modes.zeroPageYIndirect */: 2, + + 13 /* mode.zeroPageIndirect */: 2, + 14 /* mode.absoluteXIndirect */: 3, + 15 /* mode.zeroPage_relative */: 3 +}; + +/** Status register flag numbers. */ +type Flag = 0b00000001 | 0b00000010 | 0b00000100 | 0b00001000 | + 0b00010000 | 0b00100000 | 0b01000000 | 0b10000000; + +type FlagName = "N" | "V" | "B" | "D" | "I" | "Z" | "C"; + +/** Flags to status byte mask. */ +const FLAGS: Record = { + N: 0x80, // Negative + V: 0x40, // oVerflow + B: 0x10, // Break + D: 0x08, // Decimal + I: 0x04, // Interrupt + Z: 0x02, // Zero + C: 0x01 // Carry +}; + +/** CPU-referenced memory locations. */ +const loc = { + STACK: 0x100, + NMI: 0xFFFA, + RESET: 0xFFFC, + BRK: 0xFFFE +}; + +interface ReadablePage { + read(page: byte, offset: byte): byte; +} + +function isReadablePage(page: ReadablePage | any): page is ReadablePage { + return (page as ReadablePage).read !== undefined; +} + +interface WriteablePage { + write(page: byte, offset: byte, value: byte): void; +} + +function isWriteablePage(page: WriteablePage | any): page is WriteablePage { + return (page as WriteablePage).write !== undefined; +} + +interface PageHandler { + start(): byte; + end(): byte; +} + +function isResettablePageHandler(pageHandler: PageHandler | ResettablePageHandler): pageHandler is ResettablePageHandler { + return (pageHandler as ResettablePageHandler).reset !== undefined; +} + +interface ResettablePageHandler extends PageHandler { + reset(): void; +} + +const BLANK_PAGE: ReadablePage & WriteablePage = { + read: function () { return 0; }, + write: function () { } +}; + +interface Opts { + rwm?: boolean; +} + +type ReadFn = () => byte; +type WriteFn = (val: byte) => void; +type ReadAddrFn = (opts?: Opts) => word; + +type readInstruction = [ + desc: string, + op: (readFn: ReadFn) => void, + modeFn: ReadFn, + mode: mode, // really 0-15 + cycles: number, +]; + +type writeInstruction = [ + desc: string, + op: (writeFn: WriteFn) => void, + modeFn: WriteFn, + mode: mode, // really 0-15 + cycles: number, +]; + +type impliedInstruction = [ + desc: string, + op: () => void, + modeFn: null, + mode: mode, // really 0-15 + cycles: number, +]; + +type relativeInstruction = [ + desc: string, + op: (f: byte) => void, + modeFn: byte, + mode: mode, // really 0-15 + cycles: number, +]; + +type noopInstruction = [ + desc: string, + op: (readAddrFn: ReadAddrFn) => void, + modeFn: () => void, + mode: mode, // really 0-15 + cycles: number, +]; + +type instruction = + readInstruction | writeInstruction | + impliedInstruction | relativeInstruction | noopInstruction; + +interface Instructions { + [key: number]: instruction; +} + +type callback = (cpu: any) => void; // TODO(flan): Hack until there is better typing. + +function bind(op: instruction, o: CPU6502): instruction { + let op2: instruction[2] = typeof op[2] === "function" ? op[2].bind(o) : op[2]; + return [op[0], op[1].bind(o), op2, op[3], op[4]]; +} + +export default class CPU6502 { + private readonly is65C02: boolean; + + /* Registers */ + private pc = 0; // Program Counter + private sr = 0x20; // Process Status Register + private ar = 0; // Accumulator + private xr = 0; // X Register + private yr = 0; // Y Register + private sp = 0xff; // Stack Pointer + + private readPages: ReadablePage[] = []; + private writePages: WriteablePage[] = []; + private resetHandlers: ResettablePageHandler[] = []; + private cycles = 0; + private sync = false; + + constructor(options: CpuOptions = {}) { + this.is65C02 = options['65C02'] ? true : false; + + for (let idx = 0; idx < 0x100; idx++) { + this.readPages[idx] = BLANK_PAGE; + this.writePages[idx] = BLANK_PAGE; + } + } + + /** + * Set or clears `f` in the status register. `f` must be a byte with a + * single bit set. + */ + private setFlag(f: byte, on: boolean) { + this.sr = on ? (this.sr | f) : (this.sr & ~f); + } + + /** Updates the status register's zero flag and negative flag. */ + private testNZ(val: byte) { + this.sr = val === 0 ? (this.sr | FLAGS.Z) : (this.sr & ~FLAGS.Z); + this.sr = (val & 0x80) ? (this.sr | FLAGS.N) : (this.sr & ~FLAGS.N); + + return val; + } + + /** Updates the status register's zero flag. */ + private testZ(val: byte) { + this.sr = val === 0 ? (this.sr | FLAGS.Z) : (this.sr & ~FLAGS.Z); + + return val; + } + + /** + * Returns `a + b`, unless `sub` is true, in which case it performs + * `a - b`. The status register is updated according to the result. + */ + private add(a: byte, b: byte, sub: boolean) { + if (sub) + b ^= 0xff; + + // KEGS + var c, v; + if ((this.sr & FLAGS.D) !== 0) { + // BCD + c = (a & 0x0f) + (b & 0x0f) + (this.sr & FLAGS.C); + if (sub) { + if (c < 0x10) + c = (c - 0x06) & 0x0f; + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c < 0x100) + c = (c + 0xa0) & 0xff; + } else { + if (c > 0x09) + c = (c - 0x0a) | 0x10; // carry to MSN + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c > 0x99) + c += 0x60; + } + } else { + c = a + b + (this.sr & FLAGS.C); + v = (c ^ a) & 0x80; + } + + if (((a ^ b) & 0x80) !== 0) { + v = 0; + } + + this.setFlag(FLAGS.C, c > 0xff); + this.setFlag(FLAGS.V, !!v); + + return this.testNZ(c & 0xff); + } + + /** Increments `a` and returns the value, setting the status register. */ + private increment(a: byte) { + return this.testNZ((a + 0x01) & 0xff); + } + + private decrement(a: byte) { + return this.testNZ((a + 0xff) & 0xff); + } + + private readBytePC(): byte { + let addr = this.pc, + page = addr >> 8, + off = addr & 0xff; + + var result = this.readPages[page].read(page, off); + + this.pc = (this.pc + 1) & 0xffff; + + this.cycles++; + + return result; + } + + private readByte(addr: word): byte { + var page = addr >> 8, + off = addr & 0xff; + + var result = this.readPages[page].read(page, off); + + this.cycles++; + + return result; + } + + private readByteDebug(addr: word) { + var page = addr >> 8, + off = addr & 0xff; + + return this.readPages[page].read(page, off); + } + + private writeByte(addr: word, val: byte) { + var page = addr >> 8, + off = addr & 0xff; + + this.writePages[page].write(page, off, val); + + this.cycles++; + } + + private readWord(addr: word): word { + return this.readByte(addr) | (this.readByte(addr + 1) << 8); + } + + private readWordDebug(addr: word): word { + return this.readByteDebug(addr) | (this.readByteDebug(addr + 1) << 8); + } + + private readWordPC(): word { + return this.readBytePC() | (this.readBytePC() << 8); + } + + private readZPWord(addr: byte): word { + var lsb, msb; + + lsb = this.readByte(addr & 0xff); + msb = this.readByte((addr + 1) & 0xff); + + return (msb << 8) | lsb; + } + + private pushByte(val: byte) { + this.writeByte(loc.STACK | this.sp, val); + this.sp = (this.sp + 0xff) & 0xff; + } + + private pushWord(val: word) { + this.pushByte(val >> 8); + this.pushByte(val & 0xff); + } + + private pullByte(): byte { + this.sp = (this.sp + 0x01) & 0xff; + return this.readByte(loc.STACK | this.sp); + } + + private pullWordRaw(): word { + var lsb = this.pullByte(); + var msb = this.pullByte(); + + return (msb << 8) | lsb; + } + + /* + * Read functions + */ + + readImplied() { + } + + // #$00 + readImmediate(): byte { + return this.readBytePC(); + } + + // $0000 + readAbsolute(): byte { + return this.readByte(this.readWordPC()); + } + + // $00 + readZeroPage(): byte { + return this.readByte(this.readBytePC()); + } + + // $0000,X + readAbsoluteX(): byte { + var addr = this.readWordPC(); + var oldPage = addr >> 8; + addr = (addr + this.xr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // $0000,Y + readAbsoluteY(): byte { + var addr = this.readWordPC(); + var oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // $00,X + readZeroPageX(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return this.readByte((zpAddr + this.xr) & 0xff); + } + + // $00,Y + readZeroPageY(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return this.readByte((zpAddr + this.yr) & 0xff); + } + + // ($00,X) + readZeroPageXIndirect(): byte { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + var addr = this.readZPWord((zpAddr + this.xr) & 0xff); + return this.readByte(addr); + } + + // ($00),Y + readZeroPageIndirectY(): byte { + var addr = this.readZPWord(this.readBytePC()); + var oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var newPage = addr >> 8; + if (newPage != oldPage) { + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // ($00) (65C02) + readZeroPageIndirect(): byte { + return this.readByte(this.readZPWord(this.readBytePC())); + } + + /* + * Write Functions + */ + + // $0000 + writeAbsolute(val: byte) { + this.writeByte(this.readWordPC(), val); + } + + // $00 + writeZeroPage(val: byte) { + this.writeByte(this.readBytePC(), val); + } + + // $0000,X + writeAbsoluteX(val: byte) { + var addr = this.readWordPC(), oldPage = addr >> 8; + addr = (addr + this.xr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // $0000,Y + writeAbsoluteY(val: byte) { + var addr = this.readWordPC(), oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // $00,X + writeZeroPageX(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + this.writeByte((zpAddr + this.xr) & 0xff, val); + } + + // $00,Y + writeZeroPageY(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + this.writeByte((zpAddr + this.yr) & 0xff, val); + } + + // ($00,X) + writeZeroPageXIndirect(val: byte) { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + var addr = this.readZPWord((zpAddr + this.xr) & 0xff); + this.writeByte(addr, val); + } + + // ($00),Y + writeZeroPageIndirectY(val: byte) { + var addr = this.readZPWord(this.readBytePC()), oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + var off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // ($00) (65C02) + writeZeroPageIndirect(val: byte) { + this.writeByte(this.readZPWord(this.readBytePC()), val); + } + + // $00 + readAddrZeroPage(): byte { + return this.readBytePC(); + } + + // $00,X + readAddrZeroPageX() { + var zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return (zpAddr + this.xr) & 0xff; + } + + // $0000 (65C02) + readAddrAbsolute(): word { + return this.readWordPC(); + } + + // ($0000) (6502) + readAddrAbsoluteIndirectBug(): word { + var addr = this.readWordPC(); + var page = addr & 0xff00; + var off = addr & 0x00ff; + var lsb = this.readByte(addr); + var msb = this.readByte(page | ((off + 0x01) & 0xff)); + return msb << 8 | lsb; + } + + // ($0000) (65C02) + readAddrAbsoluteIndirect(): word { + var lsb = this.readBytePC(); + var msb = this.readBytePC(); + this.readByte(this.pc); + return this.readWord(msb << 8 | lsb); + } + + // $0000,X + readAddrAbsoluteX(opts: Opts = {}): word { + var addr = this.readWordPC(); + if (!this.is65C02 || opts.rwm) { + this.readByte(addr); + } else { + this.readByte(this.pc); + } + return (addr + this.xr) & 0xffff; + } + + // $(0000,X) (65C02) + readAddrAbsoluteXIndirect(): word { + var address = this.readWordPC(); + this.readByte(this.pc); + return this.readWord((address + this.xr) & 0xffff); + } + + /* Break */ + brk(val: byte) { + this.pushWord(this.pc); + this.pushByte(this.sr | FLAGS.B); + if (this.is65C02) { + this.setFlag(FLAGS.D, false); + } + this.setFlag(FLAGS.I, true); + this.pc = this.readWord(loc.BRK); + } + + /* Load Accumulator */ + lda(val: byte) { + this.ar = this.testNZ(val); + } + + /* Load X Register */ + ldx(val: byte) { + this.xr = this.testNZ(val); + } + + /* Load Y Register */ + ldy(val: byte) { + this.yr = this.testNZ(val); + } + + /* Store Accumulator */ + sta(): byte { + return this.ar; + } + + /* Store X Register */ + stx(): byte { + return this.xr; + } + + /* Store Y Register */ + sty(): byte { + return this.yr; + } + + /* Store Zero */ + stz(): byte { + return 0; + } + + /* Add with Carry */ + adc(val: byte) { + this.ar = this.add(this.ar, val, /* sub= */ false); + } + + /* Subtract with Carry */ + sbc(val: byte) { + this.ar = this.add(this.ar, val, /* sub= */ true); + } + + /* Increment Memory */ + incA() { + this.readByte(this.pc); + this.ar = this.increment(this.ar); + } + + inc(addr: word) { + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.increment(oldVal); + this.writeByte(addr, val); + } + + /* Increment X */ + inx() { + this.readByte(this.pc); + this.xr = this.increment(this.xr); + } + + /* Increment Y */ + iny() { + this.readByte(this.pc); + this.yr = this.increment(this.yr); + } + + /* Decrement Memory */ + decA() { + this.readByte(this.pc); + this.ar = this.decrement(this.ar); + } + + dec(addr: word) { + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.decrement(oldVal); + this.writeByte(addr, val); + } + + /* Decrement X */ + dex() { + this.readByte(this.pc); + this.xr = this.decrement(this.xr); + } + + /* Decrement Y */ + dey() { + this.readByte(this.pc); + this.yr = this.decrement(this.yr); + } + + shiftLeft(val: byte) { + this.setFlag(FLAGS.C, !!(val & 0x80)); + return this.testNZ((val << 1) & 0xff); + } + + /* Arithmetic Shift Left */ + aslA() { + this.readByte(this.pc); + this.ar = this.shiftLeft(this.ar); + } + + /* ASL memory */ + asl(addr: word) { + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.shiftLeft(oldVal); + this.writeByte(addr, val); + } + + shiftRight(val: byte) { + this.setFlag(FLAGS.C, !!(val & 0x01)); + return this.testNZ(val >> 1); + } + + /* Logical Shift Right */ + lsrA() { + this.readByte(this.pc); + this.ar = this.shiftRight(this.ar); + } + + lsr(addr: word) { + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.shiftRight(oldVal); + this.writeByte(addr, val); + } + + rotateLeft(val: byte) { + var c = (this.sr & FLAGS.C); + this.setFlag(FLAGS.C, !!(val & 0x80)); + return this.testNZ(((val << 1) | (c ? 0x01 : 0x00)) & 0xff); + } + + /* Rotate Left */ + rolA() { + this.readByte(this.pc); + this.ar = this.rotateLeft(this.ar); + } + + rol(addr: word) { + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.rotateLeft(oldVal); + this.writeByte(addr, val); + } + + private rotateRight(a: byte) { + var c = (this.sr & FLAGS.C); + this.setFlag(FLAGS.C, !!(a & 0x01)); + return this.testNZ((a >> 1) | (c ? 0x80 : 0x00)); + } + + /* Rotate Right */ + rorA() { + this.readByte(this.pc); + this.ar = this.rotateRight(this.ar); + } + + ror(addr: word) { + var oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + var val = this.rotateRight(oldVal); + this.writeByte(addr, val); + } + + /* Logical Or Accumulator */ + ora(val: byte) { + this.ar = this.testNZ(this.ar | val); + } + + /* Logical And Accumulator */ + and(val: byte) { + this.ar = this.testNZ(this.ar & val); + } + + /* Logical Exclusive Or Accumulator */ + eor(val: byte) { + this.ar = this.testNZ(this.ar ^ val); + } + + /* Reset Bit */ + + rmb(b: byte) { + var bit = (0x1 << b) ^ 0xFF; + var addr = this.readBytePC(); + var val = this.readByte(addr); + this.readByte(addr); + val &= bit; + this.writeByte(addr, val); + } + + /* Set Bit */ + + smb(b: byte) { + var bit = 0x1 << b; + var addr = this.readBytePC(); + var val = this.readByte(addr); + this.readByte(addr); + val |= bit; + this.writeByte(addr, val); + } + + /* Test and Reset Bits */ + trb(readAddrFn: ReadAddrFn) { + var addr = readAddrFn(); + var val = this.readByte(addr); + this.testZ(val & this.ar); + this.readByte(addr); + this.writeByte(addr, val & ~this.ar); + } + + /* Test and Set Bits */ + tsb(readAddrFn: ReadAddrFn) { + var addr = readAddrFn(); + var val = this.readByte(addr); + this.testZ(val & this.ar); + this.readByte(addr); + this.writeByte(addr, val | this.ar); + } + + /* Bit */ + bit(val: byte) { + this.setFlag(FLAGS.Z, (val & this.ar) === 0); + this.setFlag(FLAGS.N, !!(val & 0x80)); + this.setFlag(FLAGS.V, !!(val & 0x40)); + } + + /* Bit Immediate*/ + bitI(val: byte) { + this.setFlag(FLAGS.Z, (val & this.ar) === 0); + } + + private compare(a: byte, b: byte) { + b = (b ^ 0xff); + var c = a + b + 1; + this.setFlag(FLAGS.C, c > 0xff); + this.testNZ(c & 0xff); + } + + cmp(val: byte) { + this.compare(this.ar, val); + } + + cpx(val: byte) { + this.compare(this.xr, val); + } + + cpy(val: byte) { + this.compare(this.yr, val); + } + + /* Branches */ + brs(f: Flag) { + let off = this.readBytePC(); // changes pc + if ((f & this.sr) !== 0) { + this.readByte(this.pc); + let oldPage = this.pc >> 8; + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + let newOff = this.pc & 0xff; + if (newPage != oldPage) this.readByte(oldPage << 8 | newOff); + } + } + + brc(f: Flag) { + let off = this.readBytePC(); // changes pc + if ((f & this.sr) === 0) { + this.readByte(this.pc); + let oldPage = this.pc >> 8; + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + let newOff = this.pc & 0xff; + if (newPage != oldPage) this.readByte(oldPage << 8 | newOff); + } + } + + /* WDC 65C02 branches */ + + bbr(b: Flag) { + let zpAddr = this.readBytePC(); + let val = this.readByte(zpAddr); + this.readByte(zpAddr); + let off = this.readBytePC(); // changes pc + + if (((1 << b) & val) === 0) { + let oldPc = this.pc; + let oldPage = oldPc >> 8; + this.readByte(oldPc); + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + if (oldPage != newPage) { + this.readByte(oldPc); + } + } + } + + bbs(b: Flag) { + let zpAddr = this.readBytePC(); + let val = this.readByte(zpAddr); + this.readByte(zpAddr); + let off = this.readBytePC(); // changes pc + + if (((1 << b) & val) !== 0) { + let oldPc = this.pc; + let oldPage = oldPc >> 8; + this.readByte(oldPc); + this.pc += off > 127 ? off - 256 : off; + let newPage = this.pc >> 8; + if (oldPage != newPage) { + this.readByte(oldPc); + } + } + } + + /* Transfers and stack */ + tax() { this.readByte(this.pc); this.testNZ(this.xr = this.ar); } + + txa() { this.readByte(this.pc); this.testNZ(this.ar = this.xr); } + + tay() { this.readByte(this.pc); this.testNZ(this.yr = this.ar); } + + tya() { this.readByte(this.pc); this.testNZ(this.ar = this.yr); } + + tsx() { this.readByte(this.pc); this.testNZ(this.xr = this.sp); } + + txs() { this.readByte(this.pc); this.sp = this.xr; } + + pha() { this.readByte(this.pc); this.pushByte(this.ar); } + + pla() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.ar = this.pullByte()); } + + phx() { this.readByte(this.pc); this.pushByte(this.xr); } + + plx() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.xr = this.pullByte()); } + + phy() { this.readByte(this.pc); this.pushByte(this.yr); } + + ply() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.yr = this.pullByte()); } + + php() { this.readByte(this.pc); this.pushByte(this.sr | FLAGS.B); } + + plp() { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.sr = (this.pullByte() & ~FLAGS.B) | 0x20; } + + /* Jump */ + jmp(addr: word) { + this.pc = addr; + } + + /* Jump Subroutine */ + jsr() { + let lsb = this.readBytePC(); + this.readByte(0x0100 | this.sp); + this.pushWord(this.pc); + let msb = this.readBytePC(); + this.pc = (msb << 8 | lsb) & 0xffff; + } + + /* Return from Subroutine */ + rts() { + this.readByte(this.pc); + this.readByte(0x0100 | this.sp); + let addr = this.pullWordRaw(); + this.readByte(addr); + this.pc = (addr + 1) & 0xffff; + } + + /* Return from Interrupt */ + rti() { + this.readByte(this.pc); + this.readByte(0x0100 | this.sp); + this.sr = this.pullByte() & ~FLAGS.B; + this.pc = this.pullWordRaw(); + } + + /* Set and Clear */ + set(flag: Flag) { + this.readByte(this.pc); + this.sr |= flag; + } + + clr(flag: Flag) { + this.readByte(this.pc); + this.sr &= ~flag; + } + + /* No-Op */ + nop() { + this.readByte(this.pc); + } + + private dumpArgs(addr: word, m: mode, symbols: symbols) { + function toHexOrSymbol(v: word, n?: number) { + if (symbols && symbols[v]) { + return symbols[v]; + } else { + return '$' + toHex(v, n); + } + } + + let result = ''; + switch (m) { + case modes.implied: + break; + case modes.immediate: + result = '#' + toHexOrSymbol(this.readByteDebug(addr)); + break; + case modes.absolute: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4); + break; + case modes.zeroPage: + result = '' + toHexOrSymbol(this.readByteDebug(addr)); + break; + case modes.relative: + { + let off = this.readByteDebug(addr); + if (off > 127) { + off -= 256; + } + addr += off + 1; + result = '' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + } + break; + case modes.absoluteX: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',X'; + break; + case modes.absoluteY: + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',Y'; + break; + case modes.zeroPageX: + result = '' + toHexOrSymbol(this.readByteDebug(addr)) + ',X'; + break; + case modes.zeroPageY: + result = '' + toHexOrSymbol(this.readByteDebug(addr)) + ',Y'; + break; + case modes.absoluteIndirect: + result = '(' + toHexOrSymbol(this.readWordDebug(addr), 4) + ')'; + break; + case modes.zeroPageXIndirect: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + ',X)'; + break; + case modes.zeroPageIndirectY: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + '),Y'; + break; + case modes.accumulator: + result = 'A'; + break; + case modes.zeroPageIndirect: + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + ')'; + break; + case modes.absoluteXIndirect: + result = '(' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',X)'; + break; + case modes.zeroPage_relative: + let val = this.readByteDebug(addr); + let off = this.readByteDebug(addr + 1); + if (off > 127) { + off -= 256; + } + addr += off + 2; + result = '' + toHexOrSymbol(val) + ',' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + break; + default: + break; + } + return result; + } + + public step(cb: callback) { + this.sync = true; + let instruction = this.readBytePC(); + this.sync = false; + this.op(instruction); + + if (cb) { + cb(this); + } + } + + public stepDebug(n: number, cb: callback) { + for (let idx = 0; idx < n; idx++) { + this.sync = true; + let instruction = this.readBytePC(); + this.sync = false; + this.op(instruction); + + if (cb) { + cb(this); + } + } + } + + public stepCycles(c: number) { + let end = this.cycles + c; + + while (this.cycles < end) { + this.sync = true; + let instruction = this.readBytePC(); + this.sync = false; + this.op(instruction); + } + } + + public stepCyclesDebug(c: number, cb: callback): void { + var op, end = this.cycles + c; + + while (this.cycles < end) { + this.sync = true; + let instruction = this.readBytePC(); + this.sync = false; + this.op(instruction); + + if (cb) { + cb(this); + } + } + } + + public addPageHandler(pho: (PageHandler | ResettablePageHandler) & (ReadablePage | WriteablePage)) { + for (let idx = pho.start(); idx <= pho.end(); idx++) { + if (isReadablePage(pho)) + this.readPages[idx] = pho; + if (isWriteablePage(pho)) + this.writePages[idx] = pho; + } + if (isResettablePageHandler(pho)) + this.resetHandlers.push(pho); + } + + public reset() { + // cycles = 0; + this.sr = 0x20; + this.sp = 0xff; + this.ar = 0; + this.yr = 0; + this.xr = 0; + this.pc = this.readWord(loc.RESET); + + for (let idx = 0; idx < this.resetHandlers.length; idx++) { + this.resetHandlers[idx].reset(); + } + } + + /* IRQ - Interrupt Request */ + public irq() { + if ((this.sr & FLAGS.I) === 0) { + this.pushWord(this.pc); + this.pushByte(this.sr & ~FLAGS.B); + if (this.is65C02) { + this.setFlag(FLAGS.D, false); + } + this.setFlag(FLAGS.I, true); + this.pc = this.readWord(loc.BRK); + } + } + + /* NMI Non-maskable Interrupt */ + public nmi() { + this.pushWord(this.pc); + this.pushByte(this.sr & ~FLAGS.B); + if (this.is65C02) { + this.setFlag(FLAGS.D, false); + } + this.setFlag(FLAGS.I, true); + this.pc = this.readWord(loc.NMI); + } + + public getPC() { + return this.pc; + } + + public setPC(pc: word) { + this.pc = pc; + } + + // public dumpPC(pc: word, symbols: symbols) { + // if (pc === undefined) { + // pc = this.pc; + // } + // let b = this.readByte(pc), + // op = this.ops[b], + // size = sizes[op[3]], + // result = toHex(pc, 4) + '- '; + + // if (symbols) { + // if (symbols[pc]) { + // result += symbols[pc] + + // ' '.substring(symbols[pc].length); + // } else { + // result += ' '; + // } + // } + + // for (var idx = 0; idx < 4; idx++) { + // if (idx < size) { + // result += toHex(this.readByte(pc + idx)) + ' '; + // } else { + // result += ' '; + // } + // } + + // if (op === undefined) + // result += '??? (' + toHex(b) + ')'; + // else + // result += op[0] + ' ' + this.dumpArgs(pc + 1, op[3], symbols); + + // return result; + // } + + public dumpPage(start?: word, end?: word) { + var result = ''; + if (start === undefined) { + start = this.pc >> 8; + } + if (end === undefined) { + end = start; + } + for (var page = start; page <= end; page++) { + var b, idx, jdx; + for (idx = 0; idx < 16; idx++) { + result += toHex(page) + toHex(idx << 4) + ': '; + for (jdx = 0; jdx < 16; jdx++) { + b = this.readByteDebug(page * 256 + idx * 16 + jdx); + result += toHex(b) + ' '; + } + result += ' '; + for (jdx = 0; jdx < 16; jdx++) { + b = this.readByte(page * 256 + idx * 16 + jdx) & 0x7f; + if (b >= 0x20 && b < 0x7f) { + result += String.fromCharCode(b); + } else { + result += '.'; + } + } + result += '\n'; + } + } + return result; + } + + // public list(_pc: word, symbols: symbols) { + // if (_pc === undefined) { + // _pc = this.pc; + // } + // var results = []; + // for (var jdx = 0; jdx < 20; jdx++) { + // var b = this.readByte(_pc), op = this.ops[b]; + // results.push(this.dumpPC(_pc, symbols)); + // _pc += sizes[op[3]]; + // } + // return results; + // } + + public sync_() { + return this.sync; + } + + public cycles_() { + return this.cycles; + } + + public registers() { + return [this.pc, this.ar, this.xr, this.yr, this.sr, this.sp]; + } + + public getState(): CpuState { + return { + a: this.ar, + x: this.xr, + y: this.yr, + s: this.sr, + pc: this.pc, + sp: this.sp, + cycles: this.cycles + }; + } + + public setState(state: CpuState) { + this.ar = state.a; + this.xr = state.x; + this.yr = state.y; + this.sr = state.s; + this.pc = state.pc; + this.sp = state.sp; + this.cycles = state.cycles; + } + + public dumpRegisters() { + return toHex(this.pc, 4) + + '- A=' + toHex(this.ar) + + ' X=' + toHex(this.xr) + + ' Y=' + toHex(this.yr) + + ' P=' + toHex(this.sr) + + ' S=' + toHex(this.sp) + + ' ' + + ((this.sr & FLAGS.N) ? 'N' : '-') + + ((this.sr & FLAGS.V) ? 'V' : '-') + + '-' + + ((this.sr & FLAGS.B) ? 'B' : '-') + + ((this.sr & FLAGS.D) ? 'D' : '-') + + ((this.sr & FLAGS.I) ? 'I' : '-') + + ((this.sr & FLAGS.Z) ? 'Z' : '-') + + ((this.sr & FLAGS.C) ? 'C' : '-'); + } + + public read(page: byte, off: byte): byte { + return this.readPages[page].read(page, off); + } + + public write(page: byte, off: byte, val: byte) { + this.writePages[page].write(page, off, val); + } + + private op(instruction: byte) { + switch (instruction) { + // LDA + case 0xa9: this.lda(this.readImmediate()); break; + case 0xa5: this.lda(this.readZeroPage()); break; + case 0xb5: this.lda(this.readZeroPageX()); break; + case 0xad: this.lda(this.readAbsolute()); break; + case 0xbd: this.lda(this.readAbsoluteX()); break; + case 0xb9: this.lda(this.readAbsoluteY()); break; + case 0xa1: this.lda(this.readZeroPageXIndirect()); break; + case 0xb1: this.lda(this.readZeroPageIndirectY()); break; + + // LDX + case 0xa2: this.ldx(this.readImmediate()); break; + case 0xa6: this.ldx(this.readZeroPage()); break; + case 0xb6: this.ldx(this.readZeroPageY()); break; + case 0xae: this.ldx(this.readAbsolute()); break; + case 0xbe: this.ldx(this.readAbsoluteY()); break; + + // LDY + case 0xa0: this.ldy(this.readImmediate()); break; + case 0xa4: this.ldy(this.readZeroPage()); break; + case 0xb4: this.ldy(this.readZeroPageX()); break; + case 0xac: this.ldy(this.readAbsolute()); break; + case 0xbc: this.ldy(this.readAbsoluteX()); break; + + // STA + case 0x85: this.writeZeroPage(this.sta()); break; + case 0x95: this.writeZeroPageX(this.sta()); break; + case 0x8d: this.writeAbsolute(this.sta()); break; + case 0x9d: this.writeAbsoluteX(this.sta()); break; + case 0x99: this.writeAbsoluteY(this.sta()); break; + case 0x81: this.writeZeroPageXIndirect(this.sta()); break; + case 0x91: this.writeZeroPageIndirectY(this.sta()); break; + + // STX + case 0x86: this.writeZeroPage(this.stx()); break; + case 0x96: this.writeZeroPageY(this.stx()); break; + case 0x8e: this.writeAbsolute(this.stx()); break; + + // STY + case 0x84: this.writeZeroPage(this.sty()); break; + case 0x94: this.writeZeroPageX(this.sty()); break; + case 0x8c: this.writeAbsolute(this.sty()); break; + + // ADC + case 0x69: this.adc(this.readImmediate()); break; + case 0x65: this.adc(this.readZeroPage()); break; + case 0x75: this.adc(this.readZeroPageX()); break; + case 0x6D: this.adc(this.readAbsolute()); break; + case 0x7D: this.adc(this.readAbsoluteX()); break; + case 0x79: this.adc(this.readAbsoluteY()); break; + case 0x61: this.adc(this.readZeroPageXIndirect()); break; + case 0x71: this.adc(this.readZeroPageIndirectY()); break; + + // SBC + case 0xe9: this.sbc(this.readImmediate()); break; + case 0xe5: this.sbc(this.readZeroPage()); break; + case 0xf5: this.sbc(this.readZeroPageX()); break; + case 0xeD: this.sbc(this.readAbsolute()); break; + case 0xfD: this.sbc(this.readAbsoluteX()); break; + case 0xf9: this.sbc(this.readAbsoluteY()); break; + case 0xe1: this.sbc(this.readZeroPageXIndirect()); break; + case 0xf1: this.sbc(this.readZeroPageIndirectY()); break; + + // INC + case 0xe6: this.inc(this.readAddrZeroPage()); break; + case 0xf6: this.inc(this.readAddrZeroPageX()); break; + case 0xee: this.inc(this.readAddrAbsolute()); break; + case 0xfe: this.inc(this.readAddrAbsoluteX()); break; + + // INX + case 0xe8: this.inx(); break; + + // INY + case 0xc8: this.iny(); break; + + // DEC + case 0xc6: this.dec(this.readAddrZeroPage()); break; + case 0xd6: this.dec(this.readAddrZeroPageX()); break; + case 0xce: this.dec(this.readAddrAbsolute()); break; + case 0xde: this.dec(this.readAddrAbsoluteX()); break; + + // DEX + case 0xca: this.dex(); break; + + // DEY + case 0x88: this.dey(); break; + + // ASL + case 0x0A: this.aslA(); break; + case 0x06: this.asl(this.readAddrZeroPage()); break; + case 0x16: this.asl(this.readAddrZeroPageX()); break; + case 0x0E: this.asl(this.readAddrAbsolute()); break; + case 0x1E: this.asl(this.readAddrAbsoluteX()); break; + + // LSR + case 0x4A: this.lsrA(); break; + case 0x46: this.lsr(this.readAddrZeroPage()); break; + case 0x56: this.lsr(this.readAddrZeroPageX()); break; + case 0x4E: this.lsr(this.readAddrAbsolute()); break; + case 0x5E: this.lsr(this.readAddrAbsoluteX()); break; + + // ROL + case 0x2A: this.rolA(); break; + case 0x26: this.rol(this.readAddrZeroPage()); break; + case 0x36: this.rol(this.readAddrZeroPageX()); break; + case 0x2E: this.rol(this.readAddrAbsolute()); break; + case 0x3E: this.rol(this.readAddrAbsoluteX()); break; + + // ROR + case 0x6A: this.rorA(); break; + case 0x66: this.ror(this.readAddrZeroPage()); break; + case 0x76: this.ror(this.readAddrZeroPageX()); break; + case 0x6E: this.ror(this.readAddrAbsolute()); break; + case 0x7E: this.ror(this.readAddrAbsoluteX()); break; + + // AND + case 0x29: this.and(this.readImmediate()); break; + case 0x25: this.and(this.readZeroPage()); break; + case 0x35: this.and(this.readZeroPageX()); break; + case 0x2D: this.and(this.readAbsolute()); break; + case 0x3D: this.and(this.readAbsoluteX()); break; + case 0x39: this.and(this.readAbsoluteY()); break; + case 0x21: this.and(this.readZeroPageXIndirect()); break; + case 0x31: this.and(this.readZeroPageIndirectY()); break; + + // ORA + case 0x09: this.ora(this.readImmediate()); break; + case 0x05: this.ora(this.readZeroPage()); break; + case 0x15: this.ora(this.readZeroPageX()); break; + case 0x0D: this.ora(this.readAbsolute()); break; + case 0x1D: this.ora(this.readAbsoluteX()); break; + case 0x19: this.ora(this.readAbsoluteY()); break; + case 0x01: this.ora(this.readZeroPageXIndirect()); break; + case 0x11: this.ora(this.readZeroPageIndirectY()); break; + + // EOR + case 0x49: this.eor(this.readImmediate()); break; + case 0x45: this.eor(this.readZeroPage()); break; + case 0x55: this.eor(this.readZeroPageX()); break; + case 0x4D: this.eor(this.readAbsolute()); break; + case 0x5D: this.eor(this.readAbsoluteX()); break; + case 0x59: this.eor(this.readAbsoluteY()); break; + case 0x41: this.eor(this.readZeroPageXIndirect()); break; + case 0x51: this.eor(this.readZeroPageIndirectY()); break; + + // CMP + case 0xc9: this.cmp(this.readImmediate()); break; + case 0xc5: this.cmp(this.readZeroPage()); break; + case 0xd5: this.cmp(this.readZeroPageX()); break; + case 0xcD: this.cmp(this.readAbsolute()); break; + case 0xdD: this.cmp(this.readAbsoluteX()); break; + case 0xd9: this.cmp(this.readAbsoluteY()); break; + case 0xc1: this.cmp(this.readZeroPageXIndirect()); break; + case 0xd1: this.cmp(this.readZeroPageIndirectY()); break; + + // CPX + case 0xE0: this.cpx(this.readImmediate()); break; + case 0xE4: this.cpx(this.readZeroPage()); break; + case 0xEC: this.cpx(this.readAbsolute()); break; + + // CPY + case 0xC0: this.cpy(this.readImmediate()); break; + case 0xC4: this.cpy(this.readZeroPage()); break; + case 0xCC: this.cpy(this.readAbsolute()); break; + + // BIT + case 0x24: this.bit(this.readZeroPage()); break; + case 0x2C: this.bit(this.readAbsolute()); break; + + // BCC + case 0x90: this.brc(FLAGS.C); break; + + // BCS + case 0xB0: this.brs(FLAGS.C); break; + + // BEQ + case 0xF0: this.brs(FLAGS.Z); break; + + // BMI + case 0x30: this.brs(FLAGS.N); break; + + // BNE + case 0xD0: this.brc(FLAGS.Z); break; + + // BPL + case 0x10: this.brc(FLAGS.N); break; + + // BVC + case 0x50: this.brc(FLAGS.V); break; + + // BVS + case 0x70: this.brs(FLAGS.V); break; + + // TAX + case 0xAA: this.tax(); break; + + // TXA + case 0x8A: this.txa(); break; + + // TAY + case 0xA8: this.tay(); break; + + // TYA + case 0x98: this.tya(); break; + + // TSX + case 0xBA: this.tsx(); break; + + // TXS + case 0x9A: this.txs(); break; + + // PHA + case 0x48: this.pha(); break; + + // PLA + case 0x68: this.pla(); break; + + // PHP + case 0x08: this.php(); break; + + // PLP + case 0x28: this.plp(); break; + + // JMP + case 0x4C: this.jmp(this.readAddrAbsolute()); break; + case 0x6C: this.jmp(this.readAddrAbsoluteIndirectBug()); break; + + // JSR + case 0x20: this.jsr(); break; + + // RTS + case 0x60: this.rts(); break; + + // RTI + case 0x40: this.rti(); break; + + // SEC + case 0x38: this.set(FLAGS.C); break; + + // SED + case 0xF8: this.set(FLAGS.D); break; + + // SEI + case 0x78: this.set(FLAGS.I); break; + + // CLC + case 0x18: this.clr(FLAGS.C); break; + + // CLD + case 0xD8: this.clr(FLAGS.D); break; + + // CLI + case 0x58: this.clr(FLAGS.I); break; + + // CLV + case 0xB8: this.clr(FLAGS.V); break; + + // NOP + case 0xea: this.nop(); break; + + // BRK + case 0x00: this.brk(this.readImmediate()); break; + + // Unkown instructions + default: this.nop(); break; + } + } +}; + +/* +const c = CPU6502.prototype; +const OPS_6502: Instructions = { + // LDA + 0xa9: ['LDA', c.lda, c.readImmediate, modes.immediate, 2], + 0xa5: ['LDA', c.lda, c.readZeroPage, modes.zeroPage, 3], + 0xb5: ['LDA', c.lda, c.readZeroPageX, modes.zeroPageX, 4], + 0xad: ['LDA', c.lda, c.readAbsolute, modes.absolute, 4], + 0xbd: ['LDA', c.lda, c.readAbsoluteX, modes.absoluteX, 4], + 0xb9: ['LDA', c.lda, c.readAbsoluteY, modes.absoluteY, 4], + 0xa1: ['LDA', c.lda, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xb1: ['LDA', c.lda, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // LDX + 0xa2: ['LDX', c.ldx, c.readImmediate, modes.immediate, 2], + 0xa6: ['LDX', c.ldx, c.readZeroPage, modes.zeroPage, 3], + 0xb6: ['LDX', c.ldx, c.readZeroPageY, modes.zeroPageY, 4], + 0xae: ['LDX', c.ldx, c.readAbsolute, modes.absolute, 4], + 0xbe: ['LDX', c.ldx, c.readAbsoluteY, modes.absoluteY, 4], + + // LDY + 0xa0: ['LDY', c.ldy, c.readImmediate, modes.immediate, 2], + 0xa4: ['LDY', c.ldy, c.readZeroPage, modes.zeroPage, 3], + 0xb4: ['LDY', c.ldy, c.readZeroPageX, modes.zeroPageX, 4], + 0xac: ['LDY', c.ldy, c.readAbsolute, modes.absolute, 4], + 0xbc: ['LDY', c.ldy, c.readAbsoluteX, modes.absoluteX, 4], + + // STA + 0x85: ['STA', c.sta, c.writeZeroPage, modes.zeroPage, 3], + 0x95: ['STA', c.sta, c.writeZeroPageX, modes.zeroPageX, 4], + 0x8d: ['STA', c.sta, c.writeAbsolute, modes.absolute, 4], + 0x9d: ['STA', c.sta, c.writeAbsoluteX, modes.absoluteX, 5], + 0x99: ['STA', c.sta, c.writeAbsoluteY, modes.absoluteY, 5], + 0x81: ['STA', c.sta, c.writeZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x91: ['STA', c.sta, c.writeZeroPageIndirectY, modes.zeroPageIndirectY, 6], + + // STX + 0x86: ['STX', c.stx, c.writeZeroPage, modes.zeroPage, 3], + 0x96: ['STX', c.stx, c.writeZeroPageY, modes.zeroPageY, 4], + 0x8e: ['STX', c.stx, c.writeAbsolute, modes.absolute, 4], + + // STY + 0x84: ['STY', c.sty, c.writeZeroPage, modes.zeroPage, 3], + 0x94: ['STY', c.sty, c.writeZeroPageX, modes.zeroPageX, 4], + 0x8c: ['STY', c.sty, c.writeAbsolute, modes.absolute, 4], + + // ADC + 0x69: ['ADC', c.adc, c.readImmediate, modes.immediate, 2], + 0x65: ['ADC', c.adc, c.readZeroPage, modes.zeroPage, 3], + 0x75: ['ADC', c.adc, c.readZeroPageX, modes.zeroPageX, 4], + 0x6D: ['ADC', c.adc, c.readAbsolute, modes.absolute, 4], + 0x7D: ['ADC', c.adc, c.readAbsoluteX, modes.absoluteX, 4], + 0x79: ['ADC', c.adc, c.readAbsoluteY, modes.absoluteY, 4], + 0x61: ['ADC', c.adc, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x71: ['ADC', c.adc, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // SBC + 0xe9: ['SBC', c.sbc, c.readImmediate, modes.immediate, 2], + 0xe5: ['SBC', c.sbc, c.readZeroPage, modes.zeroPage, 3], + 0xf5: ['SBC', c.sbc, c.readZeroPageX, modes.zeroPageX, 4], + 0xeD: ['SBC', c.sbc, c.readAbsolute, modes.absolute, 4], + 0xfD: ['SBC', c.sbc, c.readAbsoluteX, modes.absoluteX, 4], + 0xf9: ['SBC', c.sbc, c.readAbsoluteY, modes.absoluteY, 4], + 0xe1: ['SBC', c.sbc, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xf1: ['SBC', c.sbc, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // INC + 0xe6: ['INC', c.inc, c.readAddrZeroPage, modes.zeroPage, 5], + 0xf6: ['INC', c.inc, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0xee: ['INC', c.inc, c.readAddrAbsolute, modes.absolute, 6], + 0xfe: ['INC', c.inc, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // INX + 0xe8: ['INX', c.inx, null, modes.implied, 2], + + // INY + 0xc8: ['INY', c.iny, null, modes.implied, 2], + + // DEC + 0xc6: ['DEC', c.dec, c.readAddrZeroPage, modes.zeroPage, 5], + 0xd6: ['DEC', c.dec, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0xce: ['DEC', c.dec, c.readAddrAbsolute, modes.absolute, 6], + 0xde: ['DEC', c.dec, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // DEX + 0xca: ['DEX', c.dex, null, modes.implied, 2], + + // DEY + 0x88: ['DEY', c.dey, null, modes.implied, 2], + + // ASL + 0x0A: ['ASL', c.aslA, null, modes.accumulator, 2], + 0x06: ['ASL', c.asl, c.readAddrZeroPage, modes.zeroPage, 5], + 0x16: ['ASL', c.asl, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x0E: ['ASL', c.asl, c.readAddrAbsolute, modes.absolute, 6], + 0x1E: ['ASL', c.asl, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // LSR + 0x4A: ['LSR', c.lsrA, null, modes.accumulator, 2], + 0x46: ['LSR', c.lsr, c.readAddrZeroPage, modes.zeroPage, 5], + 0x56: ['LSR', c.lsr, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x4E: ['LSR', c.lsr, c.readAddrAbsolute, modes.absolute, 6], + 0x5E: ['LSR', c.lsr, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // ROL + 0x2A: ['ROL', c.rolA, null, modes.accumulator, 2], + 0x26: ['ROL', c.rol, c.readAddrZeroPage, modes.zeroPage, 5], + 0x36: ['ROL', c.rol, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x2E: ['ROL', c.rol, c.readAddrAbsolute, modes.absolute, 6], + 0x3E: ['ROL', c.rol, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // ROR + 0x6A: ['ROR', c.rorA, null, modes.accumulator, 2], + 0x66: ['ROR', c.ror, c.readAddrZeroPage, modes.zeroPage, 5], + 0x76: ['ROR', c.ror, c.readAddrZeroPageX, modes.zeroPageX, 6], + 0x6E: ['ROR', c.ror, c.readAddrAbsolute, modes.absolute, 6], + 0x7E: ['ROR', c.ror, c.readAddrAbsoluteX, modes.absoluteX, 7], + + // AND + 0x29: ['AND', c.and, c.readImmediate, modes.immediate, 2], + 0x25: ['AND', c.and, c.readZeroPage, modes.zeroPage, 3], + 0x35: ['AND', c.and, c.readZeroPageX, modes.zeroPageX, 4], + 0x2D: ['AND', c.and, c.readAbsolute, modes.absolute, 4], + 0x3D: ['AND', c.and, c.readAbsoluteX, modes.absoluteX, 4], + 0x39: ['AND', c.and, c.readAbsoluteY, modes.absoluteY, 4], + 0x21: ['AND', c.and, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x31: ['AND', c.and, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // ORA + 0x09: ['ORA', c.ora, c.readImmediate, modes.immediate, 2], + 0x05: ['ORA', c.ora, c.readZeroPage, modes.zeroPage, 3], + 0x15: ['ORA', c.ora, c.readZeroPageX, modes.zeroPageX, 4], + 0x0D: ['ORA', c.ora, c.readAbsolute, modes.absolute, 4], + 0x1D: ['ORA', c.ora, c.readAbsoluteX, modes.absoluteX, 4], + 0x19: ['ORA', c.ora, c.readAbsoluteY, modes.absoluteY, 4], + 0x01: ['ORA', c.ora, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x11: ['ORA', c.ora, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // EOR + 0x49: ['EOR', c.eor, c.readImmediate, modes.immediate, 2], + 0x45: ['EOR', c.eor, c.readZeroPage, modes.zeroPage, 3], + 0x55: ['EOR', c.eor, c.readZeroPageX, modes.zeroPageX, 4], + 0x4D: ['EOR', c.eor, c.readAbsolute, modes.absolute, 4], + 0x5D: ['EOR', c.eor, c.readAbsoluteX, modes.absoluteX, 4], + 0x59: ['EOR', c.eor, c.readAbsoluteY, modes.absoluteY, 4], + 0x41: ['EOR', c.eor, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0x51: ['EOR', c.eor, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // CMP + 0xc9: ['CMP', c.cmp, c.readImmediate, modes.immediate, 2], + 0xc5: ['CMP', c.cmp, c.readZeroPage, modes.zeroPage, 3], + 0xd5: ['CMP', c.cmp, c.readZeroPageX, modes.zeroPageX, 4], + 0xcD: ['CMP', c.cmp, c.readAbsolute, modes.absolute, 4], + 0xdD: ['CMP', c.cmp, c.readAbsoluteX, modes.absoluteX, 4], + 0xd9: ['CMP', c.cmp, c.readAbsoluteY, modes.absoluteY, 4], + 0xc1: ['CMP', c.cmp, c.readZeroPageXIndirect, modes.zeroPageXIndirect, 6], + 0xd1: ['CMP', c.cmp, c.readZeroPageIndirectY, modes.zeroPageIndirectY, 5], + + // CPX + 0xE0: ['CPX', c.cpx, c.readImmediate, modes.immediate, 2], + 0xE4: ['CPX', c.cpx, c.readZeroPage, modes.zeroPage, 3], + 0xEC: ['CPX', c.cpx, c.readAbsolute, modes.absolute, 4], + + // CPY + 0xC0: ['CPY', c.cpy, c.readImmediate, modes.immediate, 2], + 0xC4: ['CPY', c.cpy, c.readZeroPage, modes.zeroPage, 3], + 0xCC: ['CPY', c.cpy, c.readAbsolute, modes.absolute, 4], + + // BIT + 0x24: ['BIT', c.bit, c.readZeroPage, modes.zeroPage, 3], + 0x2C: ['BIT', c.bit, c.readAbsolute, modes.absolute, 4], + + // BCC + 0x90: ['BCC', c.brc, FLAGS.C, modes.relative, 2], + + // BCS + 0xB0: ['BCS', c.brs, FLAGS.C, modes.relative, 2], + + // BEQ + 0xF0: ['BEQ', c.brs, FLAGS.Z, modes.relative, 2], + + // BMI + 0x30: ['BMI', c.brs, FLAGS.N, modes.relative, 2], + + // BNE + 0xD0: ['BNE', c.brc, FLAGS.Z, modes.relative, 2], + + // BPL + 0x10: ['BPL', c.brc, FLAGS.N, modes.relative, 2], + + // BVC + 0x50: ['BVC', c.brc, FLAGS.V, modes.relative, 2], + + // BVS + 0x70: ['BVS', c.brs, FLAGS.V, modes.relative, 2], + + // TAX + 0xAA: ['TAX', c.tax, null, modes.implied, 2], + + // TXA + 0x8A: ['TXA', c.txa, null, modes.implied, 2], + + // TAY + 0xA8: ['TAY', c.tay, null, modes.implied, 2], + + // TYA + 0x98: ['TYA', c.tya, null, modes.implied, 2], + + // TSX + 0xBA: ['TSX', c.tsx, null, modes.implied, 2], + + // TXS + 0x9A: ['TXS', c.txs, null, modes.implied, 2], + + // PHA + 0x48: ['PHA', c.pha, null, modes.implied, 3], + + // PLA + 0x68: ['PLA', c.pla, null, modes.implied, 4], + + // PHP + 0x08: ['PHP', c.php, null, modes.implied, 3], + + // PLP + 0x28: ['PLP', c.plp, null, modes.implied, 4], + + // JMP + 0x4C: [ + 'JMP', c.jmp, c.readAddrAbsolute, modes.absolute, 3 + ], + 0x6C: [ + 'JMP', c.jmp, c.readAddrAbsoluteIndirectBug, modes.absoluteIndirect, 5 + ], + // JSR + 0x20: ['JSR', c.jsr, c.readAddrAbsolute, modes.absolute, 6], + + // RTS + 0x60: ['RTS', c.rts, null, modes.implied, 6], + + // RTI + 0x40: ['RTI', c.rti, null, modes.implied, 6], + + // SEC + 0x38: ['SEC', c.set, FLAGS.C, modes.implied, 2], + + // SED + 0xF8: ['SED', c.set, FLAGS.D, modes.implied, 2], + + // SEI + 0x78: ['SEI', c.set, FLAGS.I, modes.implied, 2], + + // CLC + 0x18: ['CLC', c.clr, FLAGS.C, modes.implied, 2], + + // CLD + 0xD8: ['CLD', c.clr, FLAGS.D, modes.implied, 2], + + // CLI + 0x58: ['CLI', c.clr, FLAGS.I, modes.implied, 2], + + // CLV + 0xB8: ['CLV', c.clr, FLAGS.V, modes.implied, 2], + + // NOP + 0xea: ['NOP', c.nop, c.readImplied, modes.implied, 2], + + // BRK + 0x00: ['BRK', c.brk, c.readImmediate, modes.immediate, 7] +}; +*/ +/* 65C02 Instructions */ +/* +const OPS_65C02: Instructions = { + // INC / DEC A + 0x1A: ['INC', c.incA, null, modes.accumulator, 2], + 0x3A: ['DEC', c.decA, null, modes.accumulator, 2], + + // Indirect Zero Page for the masses + 0x12: ['ORA', c.ora, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x32: ['AND', c.and, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x52: ['EOR', c.eor, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x72: ['ADC', c.adc, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0x92: ['STA', c.sta, c.writeZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xB2: ['LDA', c.lda, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xD2: ['CMP', c.cmp, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + 0xF2: ['SBC', c.sbc, c.readZeroPageIndirect, modes.zeroPageIndirect, 5], + + // Better BIT + 0x34: ['BIT', c.bit, c.readZeroPageX, modes.zeroPageX, 4], + 0x3C: ['BIT', c.bit, c.readAbsoluteX, modes.absoluteX, 4], + 0x89: ['BIT', c.bitI, c.readImmediate, modes.immediate, 2], + + // JMP absolute indirect indexed + 0x6C: [ + 'JMP', c.jmp, c.readAddrAbsoluteIndirect, modes.absoluteIndirect, 6 + ], + 0x7C: [ + 'JMP', c.jmp, c.readAddrAbsoluteXIndirect, modes.absoluteXIndirect, 6 + ], + + // BBR/BBS + 0x0F: ['BBR0', c.bbr, 0, modes.zeroPage_relative, 5], + 0x1F: ['BBR1', c.bbr, 1, modes.zeroPage_relative, 5], + 0x2F: ['BBR2', c.bbr, 2, modes.zeroPage_relative, 5], + 0x3F: ['BBR3', c.bbr, 3, modes.zeroPage_relative, 5], + 0x4F: ['BBR4', c.bbr, 4, modes.zeroPage_relative, 5], + 0x5F: ['BBR5', c.bbr, 5, modes.zeroPage_relative, 5], + 0x6F: ['BBR6', c.bbr, 6, modes.zeroPage_relative, 5], + 0x7F: ['BBR7', c.bbr, 7, modes.zeroPage_relative, 5], + + 0x8F: ['BBS0', c.bbs, 0, modes.zeroPage_relative, 5], + 0x9F: ['BBS1', c.bbs, 1, modes.zeroPage_relative, 5], + 0xAF: ['BBS2', c.bbs, 2, modes.zeroPage_relative, 5], + 0xBF: ['BBS3', c.bbs, 3, modes.zeroPage_relative, 5], + 0xCF: ['BBS4', c.bbs, 4, modes.zeroPage_relative, 5], + 0xDF: ['BBS5', c.bbs, 5, modes.zeroPage_relative, 5], + 0xEF: ['BBS6', c.bbs, 6, modes.zeroPage_relative, 5], + 0xFF: ['BBS7', c.bbs, 7, modes.zeroPage_relative, 5], + + // BRA + 0x80: ['BRA', c.brc, 0, modes.relative, 2], + + // NOP + 0x02: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x22: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x42: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x44: ['NOP', c.nop, c.readImmediate, modes.immediate, 3], + 0x54: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0x62: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0x82: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xC2: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xD4: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0xE2: ['NOP', c.nop, c.readImmediate, modes.immediate, 2], + 0xF4: ['NOP', c.nop, c.readImmediate, modes.immediate, 4], + 0x5C: ['NOP', c.nop, c.readAbsolute, modes.absolute, 8], + 0xDC: ['NOP', c.nop, c.readAbsolute, modes.absolute, 4], + 0xFC: ['NOP', c.nop, c.readAbsolute, modes.absolute, 4], + + // PHX + 0xDA: ['PHX', c.phx, null, modes.implied, 3], + + // PHY + 0x5A: ['PHY', c.phy, null, modes.implied, 3], + + // PLX + 0xFA: ['PLX', c.plx, null, modes.implied, 4], + + // PLY + 0x7A: ['PLY', c.ply, null, modes.implied, 4], + + // RMB/SMB + + 0x07: ['RMB0', c.rmb, 0, modes.zeroPage, 5], + 0x17: ['RMB1', c.rmb, 1, modes.zeroPage, 5], + 0x27: ['RMB2', c.rmb, 2, modes.zeroPage, 5], + 0x37: ['RMB3', c.rmb, 3, modes.zeroPage, 5], + 0x47: ['RMB4', c.rmb, 4, modes.zeroPage, 5], + 0x57: ['RMB5', c.rmb, 5, modes.zeroPage, 5], + 0x67: ['RMB6', c.rmb, 6, modes.zeroPage, 5], + 0x77: ['RMB7', c.rmb, 7, modes.zeroPage, 5], + + 0x87: ['SMB0', c.smb, 0, modes.zeroPage, 5], + 0x97: ['SMB1', c.smb, 1, modes.zeroPage, 5], + 0xA7: ['SMB2', c.smb, 2, modes.zeroPage, 5], + 0xB7: ['SMB3', c.smb, 3, modes.zeroPage, 5], + 0xC7: ['SMB4', c.smb, 4, modes.zeroPage, 5], + 0xD7: ['SMB5', c.smb, 5, modes.zeroPage, 5], + 0xE7: ['SMB6', c.smb, 6, modes.zeroPage, 5], + 0xF7: ['SMB7', c.smb, 7, modes.zeroPage, 5], + + // STZ + 0x64: ['STZ', c.stz, c.writeZeroPage, modes.zeroPage, 3], + 0x74: ['STZ', c.stz, c.writeZeroPageX, modes.zeroPageX, 4], + 0x9C: ['STZ', c.stz, c.writeAbsolute, modes.absolute, 4], + 0x9E: ['STZ', c.stz, c.writeAbsoluteX, modes.absoluteX, 5], + + // TRB + 0x14: ['TRB', c.trb, c.readAddrZeroPage, modes.zeroPage, 5], + 0x1C: ['TRB', c.trb, c.readAddrAbsolute, modes.absolute, 6], + + // TSB + 0x04: ['TSB', c.tsb, c.readAddrZeroPage, modes.zeroPage, 5], + 0x0C: ['TSB', c.tsb, c.readAddrAbsolute, modes.absolute, 6] +}; +*/ \ No newline at end of file diff --git a/test/perf/test6502rom.js b/test/perf/test6502rom.js new file mode 100644 index 00000000..c06ff414 --- /dev/null +++ b/test/perf/test6502rom.js @@ -0,0 +1,8215 @@ +const MEMORY = [ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0000 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0008 + 0x00, 0x00, 0x00, 0x80, 0x01, 0xc3, 0x82, 0x41, // 0010 + 0x00, 0x7f, 0x00, 0x1f, 0x71, 0x80, 0x0f, 0xff, // 0018 + 0x7f, 0x80, 0xff, 0x0f, 0x8f, 0x8f, 0x18, 0x02, // 0020 + 0x19, 0x02, 0x1a, 0x02, 0x1b, 0x02, 0x1c, 0x02, // 0028 + 0x20, 0x01, 0x03, 0x02, 0x04, 0x02, 0x05, 0x02, // 0030 + 0x06, 0x02, 0x0b, 0x01, 0x5f, 0x02, 0x60, 0x02, // 0038 + 0x61, 0x02, 0x62, 0x02, 0x63, 0x02, 0x64, 0x02, // 0040 + 0x65, 0x02, 0x66, 0x02, 0x5b, 0x02, 0x5c, 0x02, // 0048 + 0x5d, 0x02, 0x5e, 0x02, 0x03, 0x02, 0x04, 0x02, // 0050 + 0x04, 0x01, 0x05, 0x01, 0xff, 0xff, 0xff, 0xff, // 0058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01f8 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0200 + 0x00, 0x29, 0x00, 0x60, 0x49, 0x00, 0x60, 0x09, // 0208 + 0x00, 0x60, 0x69, 0x00, 0x60, 0xe9, 0x00, 0x60, // 0210 + 0xc3, 0x82, 0x41, 0x00, 0x7f, 0x80, 0x80, 0x00, // 0218 + 0x02, 0x00, 0x02, 0x86, 0x04, 0x82, 0x00, 0x01, // 0220 + 0x03, 0x87, 0x05, 0x83, 0x01, 0x40, 0x00, 0x61, // 0228 + 0x41, 0x20, 0x00, 0xc0, 0x80, 0xe1, 0xc1, 0xa0, // 0230 + 0x80, 0x03, 0x00, 0x81, 0x01, 0x80, 0x02, 0x01, // 0238 + 0x00, 0x81, 0x01, 0x80, 0x00, 0x00, 0x03, 0x01, // 0240 + 0x00, 0x01, 0x02, 0x80, 0x81, 0x81, 0x80, 0x81, // 0248 + 0x80, 0x7f, 0x80, 0xff, 0x00, 0x01, 0x00, 0x80, // 0250 + 0x80, 0x02, 0x00, 0x00, 0x1f, 0x71, 0x80, 0x0f, // 0258 + 0xff, 0x7f, 0x80, 0xff, 0x0f, 0x8f, 0x8f, 0x00, // 0260 + 0xf1, 0x1f, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, // 0268 + 0xf0, 0xf0, 0x0f, 0x00, 0xff, 0x7f, 0x80, 0x02, // 0270 + 0x80, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, // 0278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03f8 + 0xd8, 0xa2, 0xff, 0x9a, 0xa9, 0x00, 0x8d, 0x00, // 0400 + 0x02, 0xa2, 0x05, 0x4c, 0x33, 0x04, 0xa0, 0x05, // 0408 + 0xd0, 0x08, 0x4c, 0x12, 0x04, 0x88, 0x88, 0x88, // 0410 + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0xf0, // 0418 + 0x17, 0x4c, 0x21, 0x04, 0xca, 0xca, 0xca, 0xca, // 0420 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xf0, 0xde, // 0428 + 0x4c, 0x30, 0x04, 0xd0, 0xf4, 0x4c, 0x35, 0x04, // 0430 + 0xad, 0x00, 0x02, 0xc9, 0x00, 0xd0, 0xfe, 0xa9, // 0438 + 0x01, 0x8d, 0x00, 0x02, 0xa0, 0xfe, 0x88, 0x98, // 0440 + 0xaa, 0x10, 0x08, 0x18, 0x69, 0x02, 0xea, 0xea, // 0448 + 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, // 0450 + 0x49, 0x7f, 0x8d, 0xe6, 0x04, 0xa9, 0x00, 0x4c, // 0458 + 0xe5, 0x04, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0460 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0468 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0470 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0478 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0480 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0488 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0490 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0498 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04a0 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04a8 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04b0 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04b8 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04c0 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04c8 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04d0 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04d8 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xf0, 0x3e, 0xca, // 04e0 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04e8 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04f0 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 04f8 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0500 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0508 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0510 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0518 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0520 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0528 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0530 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0538 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0540 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0548 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0550 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, // 0558 + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xea, 0xea, // 0560 + 0xea, 0xea, 0xea, 0xf0, 0x08, 0x4c, 0x6d, 0x05, // 0568 + 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, // 0570 + 0xea, 0xea, 0xc0, 0x00, 0xf0, 0x03, 0x4c, 0x46, // 0578 + 0x04, 0xad, 0x00, 0x02, 0xc9, 0x01, 0xd0, 0xfe, // 0580 + 0xa9, 0x02, 0x8d, 0x00, 0x02, 0xc0, 0x01, 0xd0, // 0588 + 0x03, 0x4c, 0x91, 0x05, 0xa9, 0x00, 0xc9, 0x00, // 0590 + 0xd0, 0xfe, 0x90, 0xfe, 0x30, 0xfe, 0xc9, 0x01, // 0598 + 0xf0, 0xfe, 0xb0, 0xfe, 0x10, 0xfe, 0xaa, 0xe0, // 05a0 + 0x00, 0xd0, 0xfe, 0x90, 0xfe, 0x30, 0xfe, 0xe0, // 05a8 + 0x01, 0xf0, 0xfe, 0xb0, 0xfe, 0x10, 0xfe, 0xa8, // 05b0 + 0xc0, 0x00, 0xd0, 0xfe, 0x90, 0xfe, 0x30, 0xfe, // 05b8 + 0xc0, 0x01, 0xf0, 0xfe, 0xb0, 0xfe, 0x10, 0xfe, // 05c0 + 0xad, 0x00, 0x02, 0xc9, 0x02, 0xd0, 0xfe, 0xa9, // 05c8 + 0x03, 0x8d, 0x00, 0x02, 0xa2, 0xff, 0x9a, 0xa9, // 05d0 + 0x55, 0x48, 0xa9, 0xaa, 0x48, 0xcd, 0xfe, 0x01, // 05d8 + 0xd0, 0xfe, 0xba, 0x8a, 0xc9, 0xfd, 0xd0, 0xfe, // 05e0 + 0x68, 0xc9, 0xaa, 0xd0, 0xfe, 0x68, 0xc9, 0x55, // 05e8 + 0xd0, 0xfe, 0xcd, 0xff, 0x01, 0xd0, 0xfe, 0xba, // 05f0 + 0xe0, 0xff, 0xd0, 0xfe, 0xad, 0x00, 0x02, 0xc9, // 05f8 + 0x03, 0xd0, 0xfe, 0xa9, 0x04, 0x8d, 0x00, 0x02, // 0600 + 0xa9, 0xff, 0x48, 0x28, 0x10, 0x1a, 0x50, 0x1b, // 0608 + 0x90, 0x1c, 0xd0, 0x1d, 0x30, 0x03, 0x4c, 0x16, // 0610 + 0x06, 0x70, 0x03, 0x4c, 0x1b, 0x06, 0xb0, 0x03, // 0618 + 0x4c, 0x20, 0x06, 0xf0, 0x0f, 0x4c, 0x25, 0x06, // 0620 + 0x4c, 0x28, 0x06, 0x4c, 0x2b, 0x06, 0x4c, 0x2e, // 0628 + 0x06, 0x4c, 0x31, 0x06, 0x08, 0xba, 0xe0, 0xfe, // 0630 + 0xd0, 0xfe, 0x68, 0xc9, 0xff, 0xd0, 0xfe, 0xba, // 0638 + 0xe0, 0xff, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, // 0640 + 0x30, 0x1a, 0x70, 0x1b, 0xb0, 0x1c, 0xf0, 0x1d, // 0648 + 0x10, 0x03, 0x4c, 0x52, 0x06, 0x50, 0x03, 0x4c, // 0650 + 0x57, 0x06, 0x90, 0x03, 0x4c, 0x5c, 0x06, 0xd0, // 0658 + 0x0f, 0x4c, 0x61, 0x06, 0x4c, 0x64, 0x06, 0x4c, // 0660 + 0x67, 0x06, 0x4c, 0x6a, 0x06, 0x4c, 0x6d, 0x06, // 0668 + 0x08, 0x68, 0xc9, 0x30, 0xd0, 0xfe, 0xa9, 0x02, // 0670 + 0x48, 0x28, 0xd0, 0x02, 0xf0, 0x03, 0x4c, 0x7e, // 0678 + 0x06, 0xb0, 0x02, 0x90, 0x03, 0x4c, 0x85, 0x06, // 0680 + 0x30, 0x02, 0x10, 0x03, 0x4c, 0x8c, 0x06, 0x70, // 0688 + 0x02, 0x50, 0x03, 0x4c, 0x93, 0x06, 0xa9, 0x01, // 0690 + 0x48, 0x28, 0xf0, 0x02, 0xd0, 0x03, 0x4c, 0x9e, // 0698 + 0x06, 0x90, 0x02, 0xb0, 0x03, 0x4c, 0xa5, 0x06, // 06a0 + 0x30, 0x02, 0x10, 0x03, 0x4c, 0xac, 0x06, 0x70, // 06a8 + 0x02, 0x50, 0x03, 0x4c, 0xb3, 0x06, 0xa9, 0x80, // 06b0 + 0x48, 0x28, 0xf0, 0x02, 0xd0, 0x03, 0x4c, 0xbe, // 06b8 + 0x06, 0xb0, 0x02, 0x90, 0x03, 0x4c, 0xc5, 0x06, // 06c0 + 0x10, 0x02, 0x30, 0x03, 0x4c, 0xcc, 0x06, 0x70, // 06c8 + 0x02, 0x50, 0x03, 0x4c, 0xd3, 0x06, 0xa9, 0x40, // 06d0 + 0x48, 0x28, 0xf0, 0x02, 0xd0, 0x03, 0x4c, 0xde, // 06d8 + 0x06, 0xb0, 0x02, 0x90, 0x03, 0x4c, 0xe5, 0x06, // 06e0 + 0x30, 0x02, 0x10, 0x03, 0x4c, 0xec, 0x06, 0x50, // 06e8 + 0x02, 0x70, 0x03, 0x4c, 0xf3, 0x06, 0xa9, 0xfd, // 06f0 + 0x48, 0x28, 0xf0, 0x02, 0xd0, 0x03, 0x4c, 0xfe, // 06f8 + 0x06, 0x90, 0x02, 0xb0, 0x03, 0x4c, 0x05, 0x07, // 0700 + 0x10, 0x02, 0x30, 0x03, 0x4c, 0x0c, 0x07, 0x50, // 0708 + 0x02, 0x70, 0x03, 0x4c, 0x13, 0x07, 0xa9, 0xfe, // 0710 + 0x48, 0x28, 0xd0, 0x02, 0xf0, 0x03, 0x4c, 0x1e, // 0718 + 0x07, 0xb0, 0x02, 0x90, 0x03, 0x4c, 0x25, 0x07, // 0720 + 0x10, 0x02, 0x30, 0x03, 0x4c, 0x2c, 0x07, 0x50, // 0728 + 0x02, 0x70, 0x03, 0x4c, 0x33, 0x07, 0xa9, 0x7f, // 0730 + 0x48, 0x28, 0xd0, 0x02, 0xf0, 0x03, 0x4c, 0x3e, // 0738 + 0x07, 0x90, 0x02, 0xb0, 0x03, 0x4c, 0x45, 0x07, // 0740 + 0x30, 0x02, 0x10, 0x03, 0x4c, 0x4c, 0x07, 0x50, // 0748 + 0x02, 0x70, 0x03, 0x4c, 0x53, 0x07, 0xa9, 0xbf, // 0750 + 0x48, 0x28, 0xd0, 0x02, 0xf0, 0x03, 0x4c, 0x5e, // 0758 + 0x07, 0x90, 0x02, 0xb0, 0x03, 0x4c, 0x65, 0x07, // 0760 + 0x10, 0x02, 0x30, 0x03, 0x4c, 0x6c, 0x07, 0x70, // 0768 + 0x02, 0x50, 0x03, 0x4c, 0x73, 0x07, 0xad, 0x00, // 0770 + 0x02, 0xc9, 0x04, 0xd0, 0xfe, 0xa9, 0x05, 0x8d, // 0778 + 0x00, 0x02, 0xa2, 0x55, 0xa0, 0xaa, 0xa9, 0xff, // 0780 + 0x48, 0xa9, 0x01, 0x28, 0x48, 0x08, 0xc9, 0x01, // 0788 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, // 0790 + 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x00, 0x28, 0x48, // 0798 + 0x08, 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 07a0 + 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, // 07a8 + 0xff, 0x28, 0x48, 0x08, 0xc9, 0xff, 0xd0, 0xfe, // 07b0 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa9, // 07b8 + 0x00, 0x48, 0xa9, 0x01, 0x28, 0x48, 0x08, 0xc9, // 07c0 + 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, // 07c8 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x00, 0x28, // 07d0 + 0x48, 0x08, 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x48, // 07d8 + 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, // 07e0 + 0xa9, 0xff, 0x28, 0x48, 0x08, 0xc9, 0xff, 0xd0, // 07e8 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 07f0 + 0xa9, 0xff, 0x48, 0xa9, 0x00, 0x28, 0x68, 0x08, // 07f8 + 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfd, // 0800 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0xff, // 0808 + 0x28, 0x68, 0x08, 0xc9, 0x00, 0xd0, 0xfe, 0x68, // 0810 + 0x48, 0xc9, 0x32, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 0818 + 0x48, 0xa9, 0xfe, 0x28, 0x68, 0x08, 0xc9, 0x01, // 0820 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, // 0828 + 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x00, 0x28, 0x68, // 0830 + 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0838 + 0xb0, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, // 0840 + 0xff, 0x28, 0x68, 0x08, 0xc9, 0x00, 0xd0, 0xfe, // 0848 + 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, 0xa9, // 0850 + 0x00, 0x48, 0xa9, 0xfe, 0x28, 0x68, 0x08, 0xc9, // 0858 + 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, // 0860 + 0xfe, 0x28, 0xe0, 0x55, 0xd0, 0xfe, 0xc0, 0xaa, // 0868 + 0xd0, 0xfe, 0xad, 0x00, 0x02, 0xc9, 0x05, 0xd0, // 0870 + 0xfe, 0xa9, 0x06, 0x8d, 0x00, 0x02, 0xa9, 0x00, // 0878 + 0x48, 0xa9, 0x3c, 0x28, 0x49, 0xc3, 0x08, 0xc9, // 0880 + 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, // 0888 + 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0xc3, 0x28, // 0890 + 0x49, 0xc3, 0x08, 0xc9, 0x00, 0xd0, 0xfe, 0x68, // 0898 + 0x48, 0xc9, 0x32, 0xd0, 0xfe, 0x28, 0xad, 0x00, // 08a0 + 0x02, 0xc9, 0x06, 0xd0, 0xfe, 0xa9, 0x07, 0x8d, // 08a8 + 0x00, 0x02, 0xa2, 0x24, 0xa0, 0x42, 0xa9, 0x00, // 08b0 + 0x48, 0xa9, 0x18, 0x28, 0xea, 0x08, 0xc9, 0x18, // 08b8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 08c0 + 0x28, 0xe0, 0x24, 0xd0, 0xfe, 0xc0, 0x42, 0xd0, // 08c8 + 0xfe, 0xa2, 0xdb, 0xa0, 0xbd, 0xa9, 0xff, 0x48, // 08d0 + 0xa9, 0xe7, 0x28, 0xea, 0x08, 0xc9, 0xe7, 0xd0, // 08d8 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 08e0 + 0xe0, 0xdb, 0xd0, 0xfe, 0xc0, 0xbd, 0xd0, 0xfe, // 08e8 + 0xad, 0x00, 0x02, 0xc9, 0x07, 0xd0, 0xfe, 0xa9, // 08f0 + 0x08, 0x8d, 0x00, 0x02, 0xa9, 0x00, 0x48, 0x28, // 08f8 + 0xa9, 0x46, 0xa2, 0x41, 0xa0, 0x52, 0x4c, 0xef, // 0900 + 0x36, 0xea, 0xea, 0xd0, 0xfe, 0xe8, 0xe8, 0xf0, // 0908 + 0xfe, 0x10, 0xfe, 0x90, 0xfe, 0x50, 0xfe, 0xc9, // 0910 + 0xec, 0xd0, 0xfe, 0xe0, 0x42, 0xd0, 0xfe, 0xc0, // 0918 + 0x4f, 0xd0, 0xfe, 0xca, 0xc8, 0xc8, 0xc8, 0x49, // 0920 + 0xaa, 0x4c, 0x32, 0x09, 0xea, 0xea, 0xd0, 0xfe, // 0928 + 0xe8, 0xe8, 0xf0, 0xfe, 0x30, 0xfe, 0x90, 0xfe, // 0930 + 0x50, 0xfe, 0xc9, 0x46, 0xd0, 0xfe, 0xe0, 0x41, // 0938 + 0xd0, 0xfe, 0xc0, 0x52, 0xd0, 0xfe, 0xad, 0x00, // 0940 + 0x02, 0xc9, 0x08, 0xd0, 0xfe, 0xa9, 0x09, 0x8d, // 0948 + 0x00, 0x02, 0xa9, 0x00, 0x48, 0x28, 0xa9, 0x49, // 0950 + 0xa2, 0x4e, 0xa0, 0x44, 0x6c, 0x1e, 0x37, 0xea, // 0958 + 0xd0, 0xfe, 0x88, 0x88, 0x08, 0x88, 0x88, 0x88, // 0960 + 0x28, 0xf0, 0xfe, 0x10, 0xfe, 0x90, 0xfe, 0x50, // 0968 + 0xfe, 0xc9, 0xe3, 0xd0, 0xfe, 0xe0, 0x4f, 0xd0, // 0970 + 0xfe, 0xc0, 0x3e, 0xd0, 0xfe, 0xba, 0xe0, 0xff, // 0978 + 0xd0, 0xfe, 0xad, 0x00, 0x02, 0xc9, 0x09, 0xd0, // 0980 + 0xfe, 0xa9, 0x0a, 0x8d, 0x00, 0x02, 0xa9, 0x00, // 0988 + 0x48, 0x28, 0xa9, 0x4a, 0xa2, 0x53, 0xa0, 0x52, // 0990 + 0x20, 0x5d, 0x37, 0x08, 0x88, 0x88, 0x88, 0x28, // 0998 + 0xf0, 0xfe, 0x10, 0xfe, 0x90, 0xfe, 0x50, 0xfe, // 09a0 + 0xc9, 0xe0, 0xd0, 0xfe, 0xe0, 0x54, 0xd0, 0xfe, // 09a8 + 0xc0, 0x4c, 0xd0, 0xfe, 0xba, 0xe0, 0xff, 0xd0, // 09b0 + 0xfe, 0xad, 0x00, 0x02, 0xc9, 0x0a, 0xd0, 0xfe, // 09b8 + 0xa9, 0x0b, 0x8d, 0x00, 0x02, 0xa9, 0x00, 0x48, // 09c0 + 0xa9, 0x42, 0xa2, 0x52, 0xa0, 0x4b, 0x28, 0x00, // 09c8 + 0x88, 0x08, 0x88, 0x88, 0x88, 0xc9, 0xe8, 0xd0, // 09d0 + 0xfe, 0xe0, 0x53, 0xd0, 0xfe, 0xc0, 0x45, 0xd0, // 09d8 + 0xfe, 0x68, 0xc9, 0x30, 0xd0, 0xfe, 0xba, 0xe0, // 09e0 + 0xff, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0xa9, 0xbd, // 09e8 + 0xa2, 0xad, 0xa0, 0xb4, 0x28, 0x00, 0x88, 0x08, // 09f0 + 0x88, 0x88, 0x88, 0xc9, 0x17, 0xd0, 0xfe, 0xe0, // 09f8 + 0xae, 0xd0, 0xfe, 0xc0, 0xae, 0xd0, 0xfe, 0x68, // 0a00 + 0xc9, 0xff, 0xd0, 0xfe, 0xba, 0xe0, 0xff, 0xd0, // 0a08 + 0xfe, 0xad, 0x00, 0x02, 0xc9, 0x0b, 0xd0, 0xfe, // 0a10 + 0xa9, 0x0c, 0x8d, 0x00, 0x02, 0xa9, 0xff, 0x48, // 0a18 + 0x28, 0x18, 0x08, 0x68, 0x48, 0xc9, 0xfe, 0xd0, // 0a20 + 0xfe, 0x28, 0x38, 0x08, 0x68, 0x48, 0xc9, 0xff, // 0a28 + 0xd0, 0xfe, 0x28, 0x58, 0x08, 0x68, 0x48, 0xc9, // 0a30 + 0xfb, 0xd0, 0xfe, 0x28, 0x78, 0x08, 0x68, 0x48, // 0a38 + 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xd8, 0x08, 0x68, // 0a40 + 0x48, 0xc9, 0xf7, 0xd0, 0xfe, 0x28, 0xf8, 0x08, // 0a48 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xb8, // 0a50 + 0x08, 0x68, 0x48, 0xc9, 0xbf, 0xd0, 0xfe, 0x28, // 0a58 + 0xa9, 0x00, 0x48, 0x28, 0x08, 0x68, 0x48, 0xc9, // 0a60 + 0x30, 0xd0, 0xfe, 0x28, 0x38, 0x08, 0x68, 0x48, // 0a68 + 0xc9, 0x31, 0xd0, 0xfe, 0x28, 0x18, 0x08, 0x68, // 0a70 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0x78, 0x08, // 0a78 + 0x68, 0x48, 0xc9, 0x34, 0xd0, 0xfe, 0x28, 0x58, // 0a80 + 0x08, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 0a88 + 0xf8, 0x08, 0x68, 0x48, 0xc9, 0x38, 0xd0, 0xfe, // 0a90 + 0x28, 0xd8, 0x08, 0x68, 0x48, 0xc9, 0x30, 0xd0, // 0a98 + 0xfe, 0x28, 0xa9, 0x40, 0x48, 0x28, 0x08, 0x68, // 0aa0 + 0x48, 0xc9, 0x70, 0xd0, 0xfe, 0x28, 0xb8, 0x08, // 0aa8 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xad, // 0ab0 + 0x00, 0x02, 0xc9, 0x0c, 0xd0, 0xfe, 0xa9, 0x0d, // 0ab8 + 0x8d, 0x00, 0x02, 0xa2, 0xfe, 0xa9, 0xff, 0x48, // 0ac0 + 0x28, 0xe8, 0x08, 0xe0, 0xff, 0xd0, 0xfe, 0x68, // 0ac8 + 0x48, 0xc9, 0xfd, 0xd0, 0xfe, 0x28, 0xe8, 0x08, // 0ad0 + 0xe0, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, // 0ad8 + 0xd0, 0xfe, 0x28, 0xe8, 0x08, 0xe0, 0x01, 0xd0, // 0ae0 + 0xfe, 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, // 0ae8 + 0xca, 0x08, 0xe0, 0x00, 0xd0, 0xfe, 0x68, 0x48, // 0af0 + 0xc9, 0x7f, 0xd0, 0xfe, 0x28, 0xca, 0x08, 0xe0, // 0af8 + 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfd, 0xd0, // 0b00 + 0xfe, 0x28, 0xca, 0xa9, 0x00, 0x48, 0x28, 0xe8, // 0b08 + 0x08, 0xe0, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0b10 + 0xb0, 0xd0, 0xfe, 0x28, 0xe8, 0x08, 0xe0, 0x00, // 0b18 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x32, 0xd0, 0xfe, // 0b20 + 0x28, 0xe8, 0x08, 0xe0, 0x01, 0xd0, 0xfe, 0x68, // 0b28 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xca, 0x08, // 0b30 + 0xe0, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x32, // 0b38 + 0xd0, 0xfe, 0x28, 0xca, 0x08, 0xe0, 0xff, 0xd0, // 0b40 + 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, 0xfe, 0x28, // 0b48 + 0xa0, 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xc8, 0x08, // 0b50 + 0xc0, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfd, // 0b58 + 0xd0, 0xfe, 0x28, 0xc8, 0x08, 0xc0, 0x00, 0xd0, // 0b60 + 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, // 0b68 + 0xc8, 0x08, 0xc0, 0x01, 0xd0, 0xfe, 0x68, 0x48, // 0b70 + 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0x88, 0x08, 0xc0, // 0b78 + 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, // 0b80 + 0xfe, 0x28, 0x88, 0x08, 0xc0, 0xff, 0xd0, 0xfe, // 0b88 + 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, 0x28, 0x88, // 0b90 + 0xa9, 0x00, 0x48, 0x28, 0xc8, 0x08, 0xc0, 0xff, // 0b98 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, 0xfe, // 0ba0 + 0x28, 0xc8, 0x08, 0xc0, 0x00, 0xd0, 0xfe, 0x68, // 0ba8 + 0x48, 0xc9, 0x32, 0xd0, 0xfe, 0x28, 0xc8, 0x08, // 0bb0 + 0xc0, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0bb8 + 0xd0, 0xfe, 0x28, 0x88, 0x08, 0xc0, 0x00, 0xd0, // 0bc0 + 0xfe, 0x68, 0x48, 0xc9, 0x32, 0xd0, 0xfe, 0x28, // 0bc8 + 0x88, 0x08, 0xc0, 0xff, 0xd0, 0xfe, 0x68, 0x48, // 0bd0 + 0xc9, 0xb0, 0xd0, 0xfe, 0x28, 0xa2, 0xff, 0xa9, // 0bd8 + 0xff, 0x48, 0x28, 0x8a, 0x08, 0xc9, 0xff, 0xd0, // 0be0 + 0xfe, 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, 0x28, // 0be8 + 0x08, 0xe8, 0x28, 0x8a, 0x08, 0xc9, 0x00, 0xd0, // 0bf0 + 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, // 0bf8 + 0x08, 0xe8, 0x28, 0x8a, 0x08, 0xc9, 0x01, 0xd0, // 0c00 + 0xfe, 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, // 0c08 + 0xa9, 0x00, 0x48, 0x28, 0x8a, 0x08, 0xc9, 0x01, // 0c10 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 0c18 + 0x28, 0x08, 0xca, 0x28, 0x8a, 0x08, 0xc9, 0x00, // 0c20 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x32, 0xd0, 0xfe, // 0c28 + 0x28, 0x08, 0xca, 0x28, 0x8a, 0x08, 0xc9, 0xff, // 0c30 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, 0xfe, // 0c38 + 0x28, 0xa0, 0xff, 0xa9, 0xff, 0x48, 0x28, 0x98, // 0c40 + 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0c48 + 0xfd, 0xd0, 0xfe, 0x28, 0x08, 0xc8, 0x28, 0x98, // 0c50 + 0x08, 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0c58 + 0x7f, 0xd0, 0xfe, 0x28, 0x08, 0xc8, 0x28, 0x98, // 0c60 + 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0c68 + 0x7d, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0x28, // 0c70 + 0x98, 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, // 0c78 + 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0x08, 0x88, 0x28, // 0c80 + 0x98, 0x08, 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x48, // 0c88 + 0xc9, 0x32, 0xd0, 0xfe, 0x28, 0x08, 0x88, 0x28, // 0c90 + 0x98, 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, // 0c98 + 0xc9, 0xb0, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, // 0ca0 + 0xa2, 0xff, 0x8a, 0x28, 0xa8, 0x08, 0xc0, 0xff, // 0ca8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, // 0cb0 + 0x28, 0x08, 0xe8, 0x8a, 0x28, 0xa8, 0x08, 0xc0, // 0cb8 + 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, // 0cc0 + 0xfe, 0x28, 0x08, 0xe8, 0x8a, 0x28, 0xa8, 0x08, // 0cc8 + 0xc0, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7d, // 0cd0 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x00, // 0cd8 + 0x8a, 0x28, 0xa8, 0x08, 0xc0, 0x01, 0xd0, 0xfe, // 0ce0 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0x08, // 0ce8 + 0xca, 0x8a, 0x28, 0xa8, 0x08, 0xc0, 0x00, 0xd0, // 0cf0 + 0xfe, 0x68, 0x48, 0xc9, 0x32, 0xd0, 0xfe, 0x28, // 0cf8 + 0x08, 0xca, 0x8a, 0x28, 0xa8, 0x08, 0xc0, 0xff, // 0d00 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, 0xfe, // 0d08 + 0x28, 0xa9, 0xff, 0x48, 0xa0, 0xff, 0x98, 0x28, // 0d10 + 0xaa, 0x08, 0xe0, 0xff, 0xd0, 0xfe, 0x68, 0x48, // 0d18 + 0xc9, 0xfd, 0xd0, 0xfe, 0x28, 0x08, 0xc8, 0x98, // 0d20 + 0x28, 0xaa, 0x08, 0xe0, 0x00, 0xd0, 0xfe, 0x68, // 0d28 + 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, 0x08, 0xc8, // 0d30 + 0x98, 0x28, 0xaa, 0x08, 0xe0, 0x01, 0xd0, 0xfe, // 0d38 + 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, // 0d40 + 0x00, 0x48, 0xa9, 0x00, 0x98, 0x28, 0xaa, 0x08, // 0d48 + 0xe0, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0d50 + 0xd0, 0xfe, 0x28, 0x08, 0x88, 0x98, 0x28, 0xaa, // 0d58 + 0x08, 0xe0, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0d60 + 0x32, 0xd0, 0xfe, 0x28, 0x08, 0x88, 0x98, 0x28, // 0d68 + 0xaa, 0x08, 0xe0, 0xff, 0xd0, 0xfe, 0x68, 0x48, // 0d70 + 0xc9, 0xb0, 0xd0, 0xfe, 0x28, 0xad, 0x00, 0x02, // 0d78 + 0xc9, 0x0d, 0xd0, 0xfe, 0xa9, 0x0e, 0x8d, 0x00, // 0d80 + 0x02, 0xa2, 0x01, 0xa9, 0xff, 0x48, 0x28, 0x9a, // 0d88 + 0x08, 0xad, 0x01, 0x01, 0xc9, 0xff, 0xd0, 0xfe, // 0d90 + 0xa9, 0x00, 0x48, 0x28, 0x9a, 0x08, 0xad, 0x01, // 0d98 + 0x01, 0xc9, 0x30, 0xd0, 0xfe, 0xca, 0xa9, 0xff, // 0da0 + 0x48, 0x28, 0x9a, 0x08, 0xad, 0x00, 0x01, 0xc9, // 0da8 + 0xff, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0x9a, // 0db0 + 0x08, 0xad, 0x00, 0x01, 0xc9, 0x30, 0xd0, 0xfe, // 0db8 + 0xca, 0xa9, 0xff, 0x48, 0x28, 0x9a, 0x08, 0xad, // 0dc0 + 0xff, 0x01, 0xc9, 0xff, 0xd0, 0xfe, 0xa9, 0x00, // 0dc8 + 0x48, 0x28, 0x9a, 0x08, 0xad, 0xff, 0x01, 0xc9, // 0dd0 + 0x30, 0xa2, 0x01, 0x9a, 0xa9, 0xff, 0x48, 0x28, // 0dd8 + 0xba, 0x08, 0xe0, 0x01, 0xd0, 0xfe, 0xad, 0x01, // 0de0 + 0x01, 0xc9, 0x7d, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 0de8 + 0x28, 0xba, 0x08, 0xe0, 0x00, 0xd0, 0xfe, 0xad, // 0df0 + 0x00, 0x01, 0xc9, 0x7f, 0xd0, 0xfe, 0xa9, 0xff, // 0df8 + 0x48, 0x28, 0xba, 0x08, 0xe0, 0xff, 0xd0, 0xfe, // 0e00 + 0xad, 0xff, 0x01, 0xc9, 0xfd, 0xd0, 0xfe, 0xa2, // 0e08 + 0x01, 0x9a, 0xa9, 0x00, 0x48, 0x28, 0xba, 0x08, // 0e10 + 0xe0, 0x01, 0xd0, 0xfe, 0xad, 0x01, 0x01, 0xc9, // 0e18 + 0x30, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xba, // 0e20 + 0x08, 0xe0, 0x00, 0xd0, 0xfe, 0xad, 0x00, 0x01, // 0e28 + 0xc9, 0x32, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, // 0e30 + 0xba, 0x08, 0xe0, 0xff, 0xd0, 0xfe, 0xad, 0xff, // 0e38 + 0x01, 0xc9, 0xb0, 0xd0, 0xfe, 0x68, 0xad, 0x00, // 0e40 + 0x02, 0xc9, 0x0e, 0xd0, 0xfe, 0xa9, 0x0f, 0x8d, // 0e48 + 0x00, 0x02, 0xa0, 0x03, 0xa9, 0x00, 0x48, 0x28, // 0e50 + 0xb6, 0x15, 0x08, 0x8a, 0x49, 0xc3, 0x28, 0x99, // 0e58 + 0x03, 0x02, 0x08, 0x49, 0xc3, 0xd9, 0x18, 0x02, // 0e60 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xd9, 0x1d, 0x02, // 0e68 + 0xd0, 0xfe, 0x88, 0x10, 0xdf, 0xa0, 0x03, 0xa9, // 0e70 + 0xff, 0x48, 0x28, 0xb6, 0x15, 0x08, 0x8a, 0x49, // 0e78 + 0xc3, 0x28, 0x99, 0x03, 0x02, 0x08, 0x49, 0xc3, // 0e80 + 0xd9, 0x18, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 0e88 + 0xd9, 0x1d, 0x02, 0xd0, 0xfe, 0x88, 0x10, 0xdf, // 0e90 + 0xa0, 0x03, 0xa9, 0x00, 0x48, 0x28, 0xbe, 0x18, // 0e98 + 0x02, 0x08, 0x8a, 0x49, 0xc3, 0xaa, 0x28, 0x96, // 0ea0 + 0x0c, 0x08, 0x49, 0xc3, 0xd9, 0x15, 0x00, 0xd0, // 0ea8 + 0xfe, 0x68, 0x49, 0x30, 0xd9, 0x1d, 0x02, 0xd0, // 0eb0 + 0xfe, 0x88, 0x10, 0xde, 0xa0, 0x03, 0xa9, 0xff, // 0eb8 + 0x48, 0x28, 0xbe, 0x18, 0x02, 0x08, 0x8a, 0x49, // 0ec0 + 0xc3, 0xaa, 0x28, 0x96, 0x0c, 0x08, 0x49, 0xc3, // 0ec8 + 0xd9, 0x15, 0x00, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 0ed0 + 0xd9, 0x1d, 0x02, 0xd0, 0xfe, 0x88, 0x10, 0xde, // 0ed8 + 0xa0, 0x03, 0xa2, 0x00, 0xb9, 0x0c, 0x00, 0x49, // 0ee0 + 0xc3, 0xd9, 0x15, 0x00, 0xd0, 0xfe, 0x96, 0x0c, // 0ee8 + 0xb9, 0x03, 0x02, 0x49, 0xc3, 0xd9, 0x18, 0x02, // 0ef0 + 0xd0, 0xfe, 0x8a, 0x99, 0x03, 0x02, 0x88, 0x10, // 0ef8 + 0xe3, 0xad, 0x00, 0x02, 0xc9, 0x0f, 0xd0, 0xfe, // 0f00 + 0xa9, 0x10, 0x8d, 0x00, 0x02, 0xa0, 0xfd, 0xb6, // 0f08 + 0x1b, 0x8a, 0x99, 0x09, 0x01, 0x88, 0xc0, 0xfa, // 0f10 + 0xb0, 0xf5, 0xa0, 0xfd, 0xbe, 0x1e, 0x01, 0x96, // 0f18 + 0x12, 0x88, 0xc0, 0xfa, 0xb0, 0xf6, 0xa0, 0x03, // 0f20 + 0xa2, 0x00, 0xb9, 0x0c, 0x00, 0xd9, 0x15, 0x00, // 0f28 + 0xd0, 0xfe, 0x96, 0x0c, 0xb9, 0x03, 0x02, 0xd9, // 0f30 + 0x18, 0x02, 0xd0, 0xfe, 0x8a, 0x99, 0x03, 0x02, // 0f38 + 0x88, 0x10, 0xe7, 0xad, 0x00, 0x02, 0xc9, 0x10, // 0f40 + 0xd0, 0xfe, 0xa9, 0x11, 0x8d, 0x00, 0x02, 0xa2, // 0f48 + 0x03, 0xa9, 0x00, 0x48, 0x28, 0xb4, 0x15, 0x08, // 0f50 + 0x98, 0x49, 0xc3, 0x28, 0x9d, 0x03, 0x02, 0x08, // 0f58 + 0x49, 0xc3, 0xdd, 0x18, 0x02, 0xd0, 0xfe, 0x68, // 0f60 + 0x49, 0x30, 0xdd, 0x1d, 0x02, 0xd0, 0xfe, 0xca, // 0f68 + 0x10, 0xdf, 0xa2, 0x03, 0xa9, 0xff, 0x48, 0x28, // 0f70 + 0xb4, 0x15, 0x08, 0x98, 0x49, 0xc3, 0x28, 0x9d, // 0f78 + 0x03, 0x02, 0x08, 0x49, 0xc3, 0xdd, 0x18, 0x02, // 0f80 + 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xdd, 0x1d, 0x02, // 0f88 + 0xd0, 0xfe, 0xca, 0x10, 0xdf, 0xa2, 0x03, 0xa9, // 0f90 + 0x00, 0x48, 0x28, 0xbc, 0x18, 0x02, 0x08, 0x98, // 0f98 + 0x49, 0xc3, 0xa8, 0x28, 0x94, 0x0c, 0x08, 0x49, // 0fa0 + 0xc3, 0xd5, 0x15, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 0fa8 + 0xdd, 0x1d, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xdf, // 0fb0 + 0xa2, 0x03, 0xa9, 0xff, 0x48, 0x28, 0xbc, 0x18, // 0fb8 + 0x02, 0x08, 0x98, 0x49, 0xc3, 0xa8, 0x28, 0x94, // 0fc0 + 0x0c, 0x08, 0x49, 0xc3, 0xd5, 0x15, 0xd0, 0xfe, // 0fc8 + 0x68, 0x49, 0x7d, 0xdd, 0x1d, 0x02, 0xd0, 0xfe, // 0fd0 + 0xca, 0x10, 0xdf, 0xa2, 0x03, 0xa0, 0x00, 0xb5, // 0fd8 + 0x0c, 0x49, 0xc3, 0xd5, 0x15, 0xd0, 0xfe, 0x94, // 0fe0 + 0x0c, 0xbd, 0x03, 0x02, 0x49, 0xc3, 0xdd, 0x18, // 0fe8 + 0x02, 0xd0, 0xfe, 0x8a, 0x9d, 0x03, 0x02, 0xca, // 0ff0 + 0x10, 0xe5, 0xad, 0x00, 0x02, 0xc9, 0x11, 0xd0, // 0ff8 + 0xfe, 0xa9, 0x12, 0x8d, 0x00, 0x02, 0xa2, 0xfd, // 1000 + 0xb4, 0x1b, 0x98, 0x9d, 0x09, 0x01, 0xca, 0xe0, // 1008 + 0xfa, 0xb0, 0xf5, 0xa2, 0xfd, 0xbc, 0x1e, 0x01, // 1010 + 0x94, 0x12, 0xca, 0xe0, 0xfa, 0xb0, 0xf6, 0xa2, // 1018 + 0x03, 0xa0, 0x00, 0xb5, 0x0c, 0xd5, 0x15, 0xd0, // 1020 + 0xfe, 0x94, 0x0c, 0xbd, 0x03, 0x02, 0xdd, 0x18, // 1028 + 0x02, 0xd0, 0xfe, 0x8a, 0x9d, 0x03, 0x02, 0xca, // 1030 + 0x10, 0xe9, 0xad, 0x00, 0x02, 0xc9, 0x12, 0xd0, // 1038 + 0xfe, 0xa9, 0x13, 0x8d, 0x00, 0x02, 0xa9, 0x00, // 1040 + 0x48, 0x28, 0xa6, 0x15, 0x08, 0x8a, 0x49, 0xc3, // 1048 + 0xaa, 0x28, 0x8e, 0x03, 0x02, 0x08, 0x49, 0xc3, // 1050 + 0xaa, 0xe0, 0xc3, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 1058 + 0xcd, 0x1d, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, // 1060 + 0x28, 0xa6, 0x16, 0x08, 0x8a, 0x49, 0xc3, 0xaa, // 1068 + 0x28, 0x8e, 0x04, 0x02, 0x08, 0x49, 0xc3, 0xaa, // 1070 + 0xe0, 0x82, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, // 1078 + 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, // 1080 + 0xa6, 0x17, 0x08, 0x8a, 0x49, 0xc3, 0xaa, 0x28, // 1088 + 0x8e, 0x05, 0x02, 0x08, 0x49, 0xc3, 0xaa, 0xe0, // 1090 + 0x41, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1f, // 1098 + 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa6, // 10a0 + 0x18, 0x08, 0x8a, 0x49, 0xc3, 0xaa, 0x28, 0x8e, // 10a8 + 0x06, 0x02, 0x08, 0x49, 0xc3, 0xaa, 0xe0, 0x00, // 10b0 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x20, 0x02, // 10b8 + 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xa6, 0x15, // 10c0 + 0x08, 0x8a, 0x49, 0xc3, 0xaa, 0x28, 0x8e, 0x03, // 10c8 + 0x02, 0x08, 0x49, 0xc3, 0xaa, 0xe0, 0xc3, 0xd0, // 10d0 + 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1d, 0x02, 0xd0, // 10d8 + 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xa6, 0x16, 0x08, // 10e0 + 0x8a, 0x49, 0xc3, 0xaa, 0x28, 0x8e, 0x04, 0x02, // 10e8 + 0x08, 0x49, 0xc3, 0xaa, 0xe0, 0x82, 0xd0, 0xfe, // 10f0 + 0x68, 0x49, 0x7d, 0xcd, 0x1e, 0x02, 0xd0, 0xfe, // 10f8 + 0xa9, 0xff, 0x48, 0x28, 0xa6, 0x17, 0x08, 0x8a, // 1100 + 0x49, 0xc3, 0xaa, 0x28, 0x8e, 0x05, 0x02, 0x08, // 1108 + 0x49, 0xc3, 0xaa, 0xe0, 0x41, 0xd0, 0xfe, 0x68, // 1110 + 0x49, 0x7d, 0xcd, 0x1f, 0x02, 0xd0, 0xfe, 0xa9, // 1118 + 0xff, 0x48, 0x28, 0xa6, 0x18, 0x08, 0x8a, 0x49, // 1120 + 0xc3, 0xaa, 0x28, 0x8e, 0x06, 0x02, 0x08, 0x49, // 1128 + 0xc3, 0xaa, 0xe0, 0x00, 0xd0, 0xfe, 0x68, 0x49, // 1130 + 0x7d, 0xcd, 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0x00, // 1138 + 0x48, 0x28, 0xae, 0x18, 0x02, 0x08, 0x8a, 0x49, // 1140 + 0xc3, 0xaa, 0x28, 0x86, 0x0c, 0x08, 0x49, 0xc3, // 1148 + 0xc5, 0x15, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, // 1150 + 0x1d, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, // 1158 + 0xae, 0x19, 0x02, 0x08, 0x8a, 0x49, 0xc3, 0xaa, // 1160 + 0x28, 0x86, 0x0d, 0x08, 0x49, 0xc3, 0xc5, 0x16, // 1168 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1e, 0x02, // 1170 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xae, 0x1a, // 1178 + 0x02, 0x08, 0x8a, 0x49, 0xc3, 0xaa, 0x28, 0x86, // 1180 + 0x0e, 0x08, 0x49, 0xc3, 0xc5, 0x17, 0xd0, 0xfe, // 1188 + 0x68, 0x49, 0x30, 0xcd, 0x1f, 0x02, 0xd0, 0xfe, // 1190 + 0xa9, 0x00, 0x48, 0x28, 0xae, 0x1b, 0x02, 0x08, // 1198 + 0x8a, 0x49, 0xc3, 0xaa, 0x28, 0x86, 0x0f, 0x08, // 11a0 + 0x49, 0xc3, 0xc5, 0x18, 0xd0, 0xfe, 0x68, 0x49, // 11a8 + 0x30, 0xcd, 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0xff, // 11b0 + 0x48, 0x28, 0xae, 0x18, 0x02, 0x08, 0x8a, 0x49, // 11b8 + 0xc3, 0xaa, 0x28, 0x86, 0x0c, 0x08, 0x49, 0xc3, // 11c0 + 0xaa, 0xe4, 0x15, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 11c8 + 0xcd, 0x1d, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 11d0 + 0x28, 0xae, 0x19, 0x02, 0x08, 0x8a, 0x49, 0xc3, // 11d8 + 0xaa, 0x28, 0x86, 0x0d, 0x08, 0x49, 0xc3, 0xaa, // 11e0 + 0xe4, 0x16, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, // 11e8 + 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, // 11f0 + 0xae, 0x1a, 0x02, 0x08, 0x8a, 0x49, 0xc3, 0xaa, // 11f8 + 0x28, 0x86, 0x0e, 0x08, 0x49, 0xc3, 0xaa, 0xe4, // 1200 + 0x17, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1f, // 1208 + 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xae, // 1210 + 0x1b, 0x02, 0x08, 0x8a, 0x49, 0xc3, 0xaa, 0x28, // 1218 + 0x86, 0x0f, 0x08, 0x49, 0xc3, 0xaa, 0xe4, 0x18, // 1220 + 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x20, 0x02, // 1228 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa2, 0xc3, // 1230 + 0x08, 0xec, 0x18, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 1238 + 0x30, 0xcd, 0x1d, 0x02, 0xd0, 0xfe, 0xa9, 0x00, // 1240 + 0x48, 0x28, 0xa2, 0x82, 0x08, 0xec, 0x19, 0x02, // 1248 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1e, 0x02, // 1250 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa2, 0x41, // 1258 + 0x08, 0xec, 0x1a, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 1260 + 0x30, 0xcd, 0x1f, 0x02, 0xd0, 0xfe, 0xa9, 0x00, // 1268 + 0x48, 0x28, 0xa2, 0x00, 0x08, 0xec, 0x1b, 0x02, // 1270 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x20, 0x02, // 1278 + 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xa2, 0xc3, // 1280 + 0x08, 0xec, 0x18, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 1288 + 0x7d, 0xcd, 0x1d, 0x02, 0xd0, 0xfe, 0xa9, 0xff, // 1290 + 0x48, 0x28, 0xa2, 0x82, 0x08, 0xec, 0x19, 0x02, // 1298 + 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1e, 0x02, // 12a0 + 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xa2, 0x41, // 12a8 + 0x08, 0xec, 0x1a, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 12b0 + 0x7d, 0xcd, 0x1f, 0x02, 0xd0, 0xfe, 0xa9, 0xff, // 12b8 + 0x48, 0x28, 0xa2, 0x00, 0x08, 0xec, 0x1b, 0x02, // 12c0 + 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x20, 0x02, // 12c8 + 0xd0, 0xfe, 0xa2, 0x00, 0xa5, 0x0c, 0x49, 0xc3, // 12d0 + 0xc5, 0x15, 0xd0, 0xfe, 0x86, 0x0c, 0xad, 0x03, // 12d8 + 0x02, 0x49, 0xc3, 0xcd, 0x18, 0x02, 0xd0, 0xfe, // 12e0 + 0x8e, 0x03, 0x02, 0xa5, 0x0d, 0x49, 0xc3, 0xc5, // 12e8 + 0x16, 0xd0, 0xfe, 0x86, 0x0d, 0xad, 0x04, 0x02, // 12f0 + 0x49, 0xc3, 0xcd, 0x19, 0x02, 0xd0, 0xfe, 0x8e, // 12f8 + 0x04, 0x02, 0xa5, 0x0e, 0x49, 0xc3, 0xc5, 0x17, // 1300 + 0xd0, 0xfe, 0x86, 0x0e, 0xad, 0x05, 0x02, 0x49, // 1308 + 0xc3, 0xcd, 0x1a, 0x02, 0xd0, 0xfe, 0x8e, 0x05, // 1310 + 0x02, 0xa5, 0x0f, 0x49, 0xc3, 0xc5, 0x18, 0xd0, // 1318 + 0xfe, 0x86, 0x0f, 0xad, 0x06, 0x02, 0x49, 0xc3, // 1320 + 0xcd, 0x1b, 0x02, 0xd0, 0xfe, 0x8e, 0x06, 0x02, // 1328 + 0xad, 0x00, 0x02, 0xc9, 0x13, 0xd0, 0xfe, 0xa9, // 1330 + 0x14, 0x8d, 0x00, 0x02, 0xa9, 0x00, 0x48, 0x28, // 1338 + 0xa4, 0x15, 0x08, 0x98, 0x49, 0xc3, 0xa8, 0x28, // 1340 + 0x8c, 0x03, 0x02, 0x08, 0x49, 0xc3, 0xa8, 0xc0, // 1348 + 0xc3, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1d, // 1350 + 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa4, // 1358 + 0x16, 0x08, 0x98, 0x49, 0xc3, 0xa8, 0x28, 0x8c, // 1360 + 0x04, 0x02, 0x08, 0x49, 0xc3, 0xa8, 0xc0, 0x82, // 1368 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1e, 0x02, // 1370 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa4, 0x17, // 1378 + 0x08, 0x98, 0x49, 0xc3, 0xa8, 0x28, 0x8c, 0x05, // 1380 + 0x02, 0x08, 0x49, 0xc3, 0xa8, 0xc0, 0x41, 0xd0, // 1388 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1f, 0x02, 0xd0, // 1390 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa4, 0x18, 0x08, // 1398 + 0x98, 0x49, 0xc3, 0xa8, 0x28, 0x8c, 0x06, 0x02, // 13a0 + 0x08, 0x49, 0xc3, 0xa8, 0xc0, 0x00, 0xd0, 0xfe, // 13a8 + 0x68, 0x49, 0x30, 0xcd, 0x20, 0x02, 0xd0, 0xfe, // 13b0 + 0xa9, 0xff, 0x48, 0x28, 0xa4, 0x15, 0x08, 0x98, // 13b8 + 0x49, 0xc3, 0xa8, 0x28, 0x8c, 0x03, 0x02, 0x08, // 13c0 + 0x49, 0xc3, 0xa8, 0xc0, 0xc3, 0xd0, 0xfe, 0x68, // 13c8 + 0x49, 0x7d, 0xcd, 0x1d, 0x02, 0xd0, 0xfe, 0xa9, // 13d0 + 0xff, 0x48, 0x28, 0xa4, 0x16, 0x08, 0x98, 0x49, // 13d8 + 0xc3, 0xa8, 0x28, 0x8c, 0x04, 0x02, 0x08, 0x49, // 13e0 + 0xc3, 0xa8, 0xc0, 0x82, 0xd0, 0xfe, 0x68, 0x49, // 13e8 + 0x7d, 0xcd, 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0xff, // 13f0 + 0x48, 0x28, 0xa4, 0x17, 0x08, 0x98, 0x49, 0xc3, // 13f8 + 0xa8, 0x28, 0x8c, 0x05, 0x02, 0x08, 0x49, 0xc3, // 1400 + 0xa8, 0xc0, 0x41, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 1408 + 0xcd, 0x1f, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 1410 + 0x28, 0xa4, 0x18, 0x08, 0x98, 0x49, 0xc3, 0xa8, // 1418 + 0x28, 0x8c, 0x06, 0x02, 0x08, 0x49, 0xc3, 0xa8, // 1420 + 0xc0, 0x00, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, // 1428 + 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, // 1430 + 0xac, 0x18, 0x02, 0x08, 0x98, 0x49, 0xc3, 0xa8, // 1438 + 0x28, 0x84, 0x0c, 0x08, 0x49, 0xc3, 0xa8, 0xc4, // 1440 + 0x15, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1d, // 1448 + 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xac, // 1450 + 0x19, 0x02, 0x08, 0x98, 0x49, 0xc3, 0xa8, 0x28, // 1458 + 0x84, 0x0d, 0x08, 0x49, 0xc3, 0xa8, 0xc4, 0x16, // 1460 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1e, 0x02, // 1468 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xac, 0x1a, // 1470 + 0x02, 0x08, 0x98, 0x49, 0xc3, 0xa8, 0x28, 0x84, // 1478 + 0x0e, 0x08, 0x49, 0xc3, 0xa8, 0xc4, 0x17, 0xd0, // 1480 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1f, 0x02, 0xd0, // 1488 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xac, 0x1b, 0x02, // 1490 + 0x08, 0x98, 0x49, 0xc3, 0xa8, 0x28, 0x84, 0x0f, // 1498 + 0x08, 0x49, 0xc3, 0xa8, 0xc4, 0x18, 0xd0, 0xfe, // 14a0 + 0x68, 0x49, 0x30, 0xcd, 0x20, 0x02, 0xd0, 0xfe, // 14a8 + 0xa9, 0xff, 0x48, 0x28, 0xac, 0x18, 0x02, 0x08, // 14b0 + 0x98, 0x49, 0xc3, 0xa8, 0x28, 0x84, 0x0c, 0x08, // 14b8 + 0x49, 0xc3, 0xa8, 0xc5, 0x15, 0xd0, 0xfe, 0x68, // 14c0 + 0x49, 0x7d, 0xcd, 0x1d, 0x02, 0xd0, 0xfe, 0xa9, // 14c8 + 0xff, 0x48, 0x28, 0xac, 0x19, 0x02, 0x08, 0x98, // 14d0 + 0x49, 0xc3, 0xa8, 0x28, 0x84, 0x0d, 0x08, 0x49, // 14d8 + 0xc3, 0xa8, 0xc5, 0x16, 0xd0, 0xfe, 0x68, 0x49, // 14e0 + 0x7d, 0xcd, 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0xff, // 14e8 + 0x48, 0x28, 0xac, 0x1a, 0x02, 0x08, 0x98, 0x49, // 14f0 + 0xc3, 0xa8, 0x28, 0x84, 0x0e, 0x08, 0x49, 0xc3, // 14f8 + 0xa8, 0xc5, 0x17, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 1500 + 0xcd, 0x1f, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 1508 + 0x28, 0xac, 0x1b, 0x02, 0x08, 0x98, 0x49, 0xc3, // 1510 + 0xa8, 0x28, 0x84, 0x0f, 0x08, 0x49, 0xc3, 0xa8, // 1518 + 0xc5, 0x18, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, // 1520 + 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, // 1528 + 0xa0, 0xc3, 0x08, 0xcc, 0x18, 0x02, 0xd0, 0xfe, // 1530 + 0x68, 0x49, 0x30, 0xcd, 0x1d, 0x02, 0xd0, 0xfe, // 1538 + 0xa9, 0x00, 0x48, 0x28, 0xa0, 0x82, 0x08, 0xcc, // 1540 + 0x19, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, // 1548 + 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, // 1550 + 0xa0, 0x41, 0x08, 0xcc, 0x1a, 0x02, 0xd0, 0xfe, // 1558 + 0x68, 0x49, 0x30, 0xcd, 0x1f, 0x02, 0xd0, 0xfe, // 1560 + 0xa9, 0x00, 0x48, 0x28, 0xa0, 0x00, 0x08, 0xcc, // 1568 + 0x1b, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, // 1570 + 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, // 1578 + 0xa0, 0xc3, 0x08, 0xcc, 0x18, 0x02, 0xd0, 0xfe, // 1580 + 0x68, 0x49, 0x7d, 0xcd, 0x1d, 0x02, 0xd0, 0xfe, // 1588 + 0xa9, 0xff, 0x48, 0x28, 0xa0, 0x82, 0x08, 0xcc, // 1590 + 0x19, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, // 1598 + 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, // 15a0 + 0xa0, 0x41, 0x08, 0xcc, 0x1a, 0x02, 0xd0, 0xfe, // 15a8 + 0x68, 0x49, 0x7d, 0xcd, 0x1f, 0x02, 0xd0, 0xfe, // 15b0 + 0xa9, 0xff, 0x48, 0x28, 0xa0, 0x00, 0x08, 0xcc, // 15b8 + 0x1b, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, // 15c0 + 0x20, 0x02, 0xd0, 0xfe, 0xa0, 0x00, 0xa5, 0x0c, // 15c8 + 0x49, 0xc3, 0xc5, 0x15, 0xd0, 0xfe, 0x84, 0x0c, // 15d0 + 0xad, 0x03, 0x02, 0x49, 0xc3, 0xcd, 0x18, 0x02, // 15d8 + 0xd0, 0xfe, 0x8c, 0x03, 0x02, 0xa5, 0x0d, 0x49, // 15e0 + 0xc3, 0xc5, 0x16, 0xd0, 0xfe, 0x84, 0x0d, 0xad, // 15e8 + 0x04, 0x02, 0x49, 0xc3, 0xcd, 0x19, 0x02, 0xd0, // 15f0 + 0xfe, 0x8c, 0x04, 0x02, 0xa5, 0x0e, 0x49, 0xc3, // 15f8 + 0xc5, 0x17, 0xd0, 0xfe, 0x84, 0x0e, 0xad, 0x05, // 1600 + 0x02, 0x49, 0xc3, 0xcd, 0x1a, 0x02, 0xd0, 0xfe, // 1608 + 0x8c, 0x05, 0x02, 0xa5, 0x0f, 0x49, 0xc3, 0xc5, // 1610 + 0x18, 0xd0, 0xfe, 0x84, 0x0f, 0xad, 0x06, 0x02, // 1618 + 0x49, 0xc3, 0xcd, 0x1b, 0x02, 0xd0, 0xfe, 0x8c, // 1620 + 0x06, 0x02, 0xad, 0x00, 0x02, 0xc9, 0x14, 0xd0, // 1628 + 0xfe, 0xa9, 0x15, 0x8d, 0x00, 0x02, 0xa2, 0x03, // 1630 + 0xa9, 0x00, 0x48, 0x28, 0xb5, 0x15, 0x08, 0x49, // 1638 + 0xc3, 0x28, 0x9d, 0x03, 0x02, 0x08, 0x49, 0xc3, // 1640 + 0xdd, 0x18, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 1648 + 0xdd, 0x1d, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe0, // 1650 + 0xa2, 0x03, 0xa9, 0xff, 0x48, 0x28, 0xb5, 0x15, // 1658 + 0x08, 0x49, 0xc3, 0x28, 0x9d, 0x03, 0x02, 0x08, // 1660 + 0x49, 0xc3, 0xdd, 0x18, 0x02, 0xd0, 0xfe, 0x68, // 1668 + 0x49, 0x7d, 0xdd, 0x1d, 0x02, 0xd0, 0xfe, 0xca, // 1670 + 0x10, 0xe0, 0xa2, 0x03, 0xa9, 0x00, 0x48, 0x28, // 1678 + 0xbd, 0x18, 0x02, 0x08, 0x49, 0xc3, 0x28, 0x95, // 1680 + 0x0c, 0x08, 0x49, 0xc3, 0xd5, 0x15, 0xd0, 0xfe, // 1688 + 0x68, 0x49, 0x30, 0xdd, 0x1d, 0x02, 0xd0, 0xfe, // 1690 + 0xca, 0x10, 0xe1, 0xa2, 0x03, 0xa9, 0xff, 0x48, // 1698 + 0x28, 0xbd, 0x18, 0x02, 0x08, 0x49, 0xc3, 0x28, // 16a0 + 0x95, 0x0c, 0x08, 0x49, 0xc3, 0xd5, 0x15, 0xd0, // 16a8 + 0xfe, 0x68, 0x49, 0x7d, 0xdd, 0x1d, 0x02, 0xd0, // 16b0 + 0xfe, 0xca, 0x10, 0xe1, 0xa2, 0x03, 0xa0, 0x00, // 16b8 + 0xb5, 0x0c, 0x49, 0xc3, 0xd5, 0x15, 0xd0, 0xfe, // 16c0 + 0x94, 0x0c, 0xbd, 0x03, 0x02, 0x49, 0xc3, 0xdd, // 16c8 + 0x18, 0x02, 0xd0, 0xfe, 0x8a, 0x9d, 0x03, 0x02, // 16d0 + 0xca, 0x10, 0xe5, 0xad, 0x00, 0x02, 0xc9, 0x15, // 16d8 + 0xd0, 0xfe, 0xa9, 0x16, 0x8d, 0x00, 0x02, 0xa0, // 16e0 + 0x03, 0xa9, 0x00, 0x48, 0x28, 0xb1, 0x26, 0x08, // 16e8 + 0x49, 0xc3, 0x28, 0x99, 0x03, 0x02, 0x08, 0x49, // 16f0 + 0xc3, 0xd9, 0x18, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 16f8 + 0x30, 0xd9, 0x1d, 0x02, 0xd0, 0xfe, 0x88, 0x10, // 1700 + 0xe0, 0xa0, 0x03, 0xa9, 0xff, 0x48, 0x28, 0xb1, // 1708 + 0x26, 0x08, 0x49, 0xc3, 0x28, 0x99, 0x03, 0x02, // 1710 + 0x08, 0x49, 0xc3, 0xd9, 0x18, 0x02, 0xd0, 0xfe, // 1718 + 0x68, 0x49, 0x7d, 0xd9, 0x1d, 0x02, 0xd0, 0xfe, // 1720 + 0x88, 0x10, 0xe0, 0xa0, 0x03, 0xa2, 0x00, 0xb9, // 1728 + 0x03, 0x02, 0x49, 0xc3, 0xd9, 0x18, 0x02, 0xd0, // 1730 + 0xfe, 0x8a, 0x99, 0x03, 0x02, 0x88, 0x10, 0xef, // 1738 + 0xa0, 0x03, 0xa9, 0x00, 0x48, 0x28, 0xb9, 0x18, // 1740 + 0x02, 0x08, 0x49, 0xc3, 0x28, 0x91, 0x32, 0x08, // 1748 + 0x49, 0xc3, 0xd1, 0x26, 0xd0, 0xfe, 0x68, 0x49, // 1750 + 0x30, 0xd9, 0x1d, 0x02, 0xd0, 0xfe, 0x88, 0x10, // 1758 + 0xe1, 0xa0, 0x03, 0xa9, 0xff, 0x48, 0x28, 0xb9, // 1760 + 0x18, 0x02, 0x08, 0x49, 0xc3, 0x28, 0x91, 0x32, // 1768 + 0x08, 0x49, 0xc3, 0xd1, 0x26, 0xd0, 0xfe, 0x68, // 1770 + 0x49, 0x7d, 0xd9, 0x1d, 0x02, 0xd0, 0xfe, 0x88, // 1778 + 0x10, 0xe1, 0xa0, 0x03, 0xa2, 0x00, 0xb9, 0x03, // 1780 + 0x02, 0x49, 0xc3, 0xd9, 0x18, 0x02, 0xd0, 0xfe, // 1788 + 0x8a, 0x99, 0x03, 0x02, 0x88, 0x10, 0xef, 0xa2, // 1790 + 0x06, 0xa0, 0x03, 0xa9, 0x00, 0x48, 0x28, 0xa1, // 1798 + 0x26, 0x08, 0x49, 0xc3, 0x28, 0x81, 0x32, 0x08, // 17a0 + 0x49, 0xc3, 0xd9, 0x18, 0x02, 0xd0, 0xfe, 0x68, // 17a8 + 0x49, 0x30, 0xd9, 0x1d, 0x02, 0xd0, 0xfe, 0xca, // 17b0 + 0xca, 0x88, 0x10, 0xdf, 0xa2, 0x06, 0xa0, 0x03, // 17b8 + 0xa9, 0xff, 0x48, 0x28, 0xa1, 0x26, 0x08, 0x49, // 17c0 + 0xc3, 0x28, 0x81, 0x32, 0x08, 0x49, 0xc3, 0xd9, // 17c8 + 0x18, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xd9, // 17d0 + 0x1d, 0x02, 0xd0, 0xfe, 0xca, 0xca, 0x88, 0x10, // 17d8 + 0xdf, 0xa0, 0x03, 0xa2, 0x00, 0xb9, 0x03, 0x02, // 17e0 + 0x49, 0xc3, 0xd9, 0x18, 0x02, 0xd0, 0xfe, 0x8a, // 17e8 + 0x99, 0x03, 0x02, 0x88, 0x10, 0xef, 0xad, 0x00, // 17f0 + 0x02, 0xc9, 0x16, 0xd0, 0xfe, 0xa9, 0x17, 0x8d, // 17f8 + 0x00, 0x02, 0xa2, 0xfd, 0xb5, 0x1b, 0x9d, 0x09, // 1800 + 0x01, 0xca, 0xe0, 0xfa, 0xb0, 0xf6, 0xa2, 0xfd, // 1808 + 0xbd, 0x1e, 0x01, 0x95, 0x12, 0xca, 0xe0, 0xfa, // 1810 + 0xb0, 0xf6, 0xa2, 0x03, 0xa0, 0x00, 0xb5, 0x0c, // 1818 + 0xd5, 0x15, 0xd0, 0xfe, 0x94, 0x0c, 0xbd, 0x03, // 1820 + 0x02, 0xdd, 0x18, 0x02, 0xd0, 0xfe, 0x8a, 0x9d, // 1828 + 0x03, 0x02, 0xca, 0x10, 0xe9, 0xa0, 0xfb, 0xa2, // 1830 + 0xfe, 0xa1, 0x2e, 0x99, 0x0b, 0x01, 0xca, 0xca, // 1838 + 0x88, 0xc0, 0xf8, 0xb0, 0xf4, 0xa0, 0x03, 0xa2, // 1840 + 0x00, 0xb9, 0x03, 0x02, 0xd9, 0x18, 0x02, 0xd0, // 1848 + 0xfe, 0x8a, 0x99, 0x03, 0x02, 0x88, 0x10, 0xf1, // 1850 + 0xa0, 0xfb, 0xb9, 0x20, 0x01, 0x91, 0x3a, 0x88, // 1858 + 0xc0, 0xf8, 0xb0, 0xf6, 0xa0, 0x03, 0xa2, 0x00, // 1860 + 0xb9, 0x03, 0x02, 0xd9, 0x18, 0x02, 0xd0, 0xfe, // 1868 + 0x8a, 0x99, 0x03, 0x02, 0x88, 0x10, 0xf1, 0xa0, // 1870 + 0xfb, 0xa2, 0xfe, 0xb1, 0x30, 0x81, 0x3a, 0xca, // 1878 + 0xca, 0x88, 0xc0, 0xf8, 0xb0, 0xf5, 0xa0, 0x03, // 1880 + 0xa2, 0x00, 0xb9, 0x03, 0x02, 0xd9, 0x18, 0x02, // 1888 + 0xd0, 0xfe, 0x8a, 0x99, 0x03, 0x02, 0x88, 0x10, // 1890 + 0xf1, 0xad, 0x00, 0x02, 0xc9, 0x17, 0xd0, 0xfe, // 1898 + 0xa9, 0x18, 0x8d, 0x00, 0x02, 0xa9, 0x00, 0x48, // 18a0 + 0x28, 0xa5, 0x15, 0x08, 0x49, 0xc3, 0x28, 0x8d, // 18a8 + 0x03, 0x02, 0x08, 0x49, 0xc3, 0xc9, 0xc3, 0xd0, // 18b0 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1d, 0x02, 0xd0, // 18b8 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa5, 0x16, 0x08, // 18c0 + 0x49, 0xc3, 0x28, 0x8d, 0x04, 0x02, 0x08, 0x49, // 18c8 + 0xc3, 0xc9, 0x82, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 18d0 + 0xcd, 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, // 18d8 + 0x28, 0xa5, 0x17, 0x08, 0x49, 0xc3, 0x28, 0x8d, // 18e0 + 0x05, 0x02, 0x08, 0x49, 0xc3, 0xc9, 0x41, 0xd0, // 18e8 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1f, 0x02, 0xd0, // 18f0 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa5, 0x18, 0x08, // 18f8 + 0x49, 0xc3, 0x28, 0x8d, 0x06, 0x02, 0x08, 0x49, // 1900 + 0xc3, 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 1908 + 0xcd, 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 1910 + 0x28, 0xa5, 0x15, 0x08, 0x49, 0xc3, 0x28, 0x8d, // 1918 + 0x03, 0x02, 0x08, 0x49, 0xc3, 0xc9, 0xc3, 0xd0, // 1920 + 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1d, 0x02, 0xd0, // 1928 + 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xa5, 0x16, 0x08, // 1930 + 0x49, 0xc3, 0x28, 0x8d, 0x04, 0x02, 0x08, 0x49, // 1938 + 0xc3, 0xc9, 0x82, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 1940 + 0xcd, 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 1948 + 0x28, 0xa5, 0x17, 0x08, 0x49, 0xc3, 0x28, 0x8d, // 1950 + 0x05, 0x02, 0x08, 0x49, 0xc3, 0xc9, 0x41, 0xd0, // 1958 + 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1f, 0x02, 0xd0, // 1960 + 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xa5, 0x18, 0x08, // 1968 + 0x49, 0xc3, 0x28, 0x8d, 0x06, 0x02, 0x08, 0x49, // 1970 + 0xc3, 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 1978 + 0xcd, 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, // 1980 + 0x28, 0xad, 0x18, 0x02, 0x08, 0x49, 0xc3, 0x28, // 1988 + 0x85, 0x0c, 0x08, 0x49, 0xc3, 0xc5, 0x15, 0xd0, // 1990 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1d, 0x02, 0xd0, // 1998 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xad, 0x19, 0x02, // 19a0 + 0x08, 0x49, 0xc3, 0x28, 0x85, 0x0d, 0x08, 0x49, // 19a8 + 0xc3, 0xc5, 0x16, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 19b0 + 0xcd, 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, // 19b8 + 0x28, 0xad, 0x1a, 0x02, 0x08, 0x49, 0xc3, 0x28, // 19c0 + 0x85, 0x0e, 0x08, 0x49, 0xc3, 0xc5, 0x17, 0xd0, // 19c8 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1f, 0x02, 0xd0, // 19d0 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xad, 0x1b, 0x02, // 19d8 + 0x08, 0x49, 0xc3, 0x28, 0x85, 0x0f, 0x08, 0x49, // 19e0 + 0xc3, 0xc5, 0x18, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 19e8 + 0xcd, 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 19f0 + 0x28, 0xad, 0x18, 0x02, 0x08, 0x49, 0xc3, 0x28, // 19f8 + 0x85, 0x0c, 0x08, 0x49, 0xc3, 0xc5, 0x15, 0xd0, // 1a00 + 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1d, 0x02, 0xd0, // 1a08 + 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xad, 0x19, 0x02, // 1a10 + 0x08, 0x49, 0xc3, 0x28, 0x85, 0x0d, 0x08, 0x49, // 1a18 + 0xc3, 0xc5, 0x16, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 1a20 + 0xcd, 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 1a28 + 0x28, 0xad, 0x1a, 0x02, 0x08, 0x49, 0xc3, 0x28, // 1a30 + 0x85, 0x0e, 0x08, 0x49, 0xc3, 0xc5, 0x17, 0xd0, // 1a38 + 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1f, 0x02, 0xd0, // 1a40 + 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xad, 0x1b, 0x02, // 1a48 + 0x08, 0x49, 0xc3, 0x28, 0x85, 0x0f, 0x08, 0x49, // 1a50 + 0xc3, 0xc5, 0x18, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 1a58 + 0xcd, 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, // 1a60 + 0x28, 0xa9, 0xc3, 0x08, 0xcd, 0x18, 0x02, 0xd0, // 1a68 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1d, 0x02, 0xd0, // 1a70 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa9, 0x82, 0x08, // 1a78 + 0xcd, 0x19, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 1a80 + 0xcd, 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, // 1a88 + 0x28, 0xa9, 0x41, 0x08, 0xcd, 0x1a, 0x02, 0xd0, // 1a90 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x1f, 0x02, 0xd0, // 1a98 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xa9, 0x00, 0x08, // 1aa0 + 0xcd, 0x1b, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 1aa8 + 0xcd, 0x20, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 1ab0 + 0x28, 0xa9, 0xc3, 0x08, 0xcd, 0x18, 0x02, 0xd0, // 1ab8 + 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1d, 0x02, 0xd0, // 1ac0 + 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xa9, 0x82, 0x08, // 1ac8 + 0xcd, 0x19, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 1ad0 + 0xcd, 0x1e, 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, // 1ad8 + 0x28, 0xa9, 0x41, 0x08, 0xcd, 0x1a, 0x02, 0xd0, // 1ae0 + 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x1f, 0x02, 0xd0, // 1ae8 + 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xa9, 0x00, 0x08, // 1af0 + 0xcd, 0x1b, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 1af8 + 0xcd, 0x20, 0x02, 0xd0, 0xfe, 0xa2, 0x00, 0xa5, // 1b00 + 0x0c, 0x49, 0xc3, 0xc5, 0x15, 0xd0, 0xfe, 0x86, // 1b08 + 0x0c, 0xad, 0x03, 0x02, 0x49, 0xc3, 0xcd, 0x18, // 1b10 + 0x02, 0xd0, 0xfe, 0x8e, 0x03, 0x02, 0xa5, 0x0d, // 1b18 + 0x49, 0xc3, 0xc5, 0x16, 0xd0, 0xfe, 0x86, 0x0d, // 1b20 + 0xad, 0x04, 0x02, 0x49, 0xc3, 0xcd, 0x19, 0x02, // 1b28 + 0xd0, 0xfe, 0x8e, 0x04, 0x02, 0xa5, 0x0e, 0x49, // 1b30 + 0xc3, 0xc5, 0x17, 0xd0, 0xfe, 0x86, 0x0e, 0xad, // 1b38 + 0x05, 0x02, 0x49, 0xc3, 0xcd, 0x1a, 0x02, 0xd0, // 1b40 + 0xfe, 0x8e, 0x05, 0x02, 0xa5, 0x0f, 0x49, 0xc3, // 1b48 + 0xc5, 0x18, 0xd0, 0xfe, 0x86, 0x0f, 0xad, 0x06, // 1b50 + 0x02, 0x49, 0xc3, 0xcd, 0x1b, 0x02, 0xd0, 0xfe, // 1b58 + 0x8e, 0x06, 0x02, 0xad, 0x00, 0x02, 0xc9, 0x18, // 1b60 + 0xd0, 0xfe, 0xa9, 0x19, 0x8d, 0x00, 0x02, 0xa9, // 1b68 + 0x00, 0x48, 0xa9, 0xff, 0x28, 0x24, 0x18, 0x08, // 1b70 + 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x32, // 1b78 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x01, // 1b80 + 0x28, 0x24, 0x17, 0x08, 0xc9, 0x01, 0xd0, 0xfe, // 1b88 + 0x68, 0x48, 0xc9, 0x70, 0xd0, 0xfe, 0x28, 0xa9, // 1b90 + 0x00, 0x48, 0xa9, 0x01, 0x28, 0x24, 0x16, 0x08, // 1b98 + 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb2, // 1ba0 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x01, // 1ba8 + 0x28, 0x24, 0x15, 0x08, 0xc9, 0x01, 0xd0, 0xfe, // 1bb0 + 0x68, 0x48, 0xc9, 0xf0, 0xd0, 0xfe, 0x28, 0xa9, // 1bb8 + 0xff, 0x48, 0xa9, 0xff, 0x28, 0x24, 0x18, 0x08, // 1bc0 + 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x3f, // 1bc8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x01, // 1bd0 + 0x28, 0x24, 0x17, 0x08, 0xc9, 0x01, 0xd0, 0xfe, // 1bd8 + 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, // 1be0 + 0xff, 0x48, 0xa9, 0x01, 0x28, 0x24, 0x16, 0x08, // 1be8 + 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xbf, // 1bf0 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x01, // 1bf8 + 0x28, 0x24, 0x15, 0x08, 0xc9, 0x01, 0xd0, 0xfe, // 1c00 + 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, 0x28, 0xa9, // 1c08 + 0x00, 0x48, 0xa9, 0xff, 0x28, 0x2c, 0x1b, 0x02, // 1c10 + 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1c18 + 0x32, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, // 1c20 + 0x01, 0x28, 0x2c, 0x1a, 0x02, 0x08, 0xc9, 0x01, // 1c28 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x70, 0xd0, 0xfe, // 1c30 + 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x01, 0x28, 0x2c, // 1c38 + 0x19, 0x02, 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, // 1c40 + 0x48, 0xc9, 0xb2, 0xd0, 0xfe, 0x28, 0xa9, 0x00, // 1c48 + 0x48, 0xa9, 0x01, 0x28, 0x2c, 0x18, 0x02, 0x08, // 1c50 + 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xf0, // 1c58 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xff, // 1c60 + 0x28, 0x2c, 0x1b, 0x02, 0x08, 0xc9, 0xff, 0xd0, // 1c68 + 0xfe, 0x68, 0x48, 0xc9, 0x3f, 0xd0, 0xfe, 0x28, // 1c70 + 0xa9, 0xff, 0x48, 0xa9, 0x01, 0x28, 0x2c, 0x1a, // 1c78 + 0x02, 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, // 1c80 + 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, // 1c88 + 0xa9, 0x01, 0x28, 0x2c, 0x19, 0x02, 0x08, 0xc9, // 1c90 + 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xbf, 0xd0, // 1c98 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x01, 0x28, // 1ca0 + 0x2c, 0x18, 0x02, 0x08, 0xc9, 0x01, 0xd0, 0xfe, // 1ca8 + 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, 0x28, 0xad, // 1cb0 + 0x00, 0x02, 0xc9, 0x19, 0xd0, 0xfe, 0xa9, 0x1a, // 1cb8 + 0x8d, 0x00, 0x02, 0xa9, 0x00, 0x48, 0xa2, 0x80, // 1cc0 + 0x28, 0xe4, 0x19, 0x08, 0x68, 0x48, 0xc9, 0x31, // 1cc8 + 0xd0, 0xfe, 0x28, 0xca, 0xe4, 0x19, 0x08, 0x68, // 1cd0 + 0x48, 0xc9, 0x33, 0xd0, 0xfe, 0x28, 0xca, 0xe4, // 1cd8 + 0x19, 0x08, 0xe0, 0x7e, 0xd0, 0xfe, 0x68, 0x48, // 1ce0 + 0xc9, 0xb0, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, // 1ce8 + 0xa2, 0x80, 0x28, 0xe4, 0x19, 0x08, 0x68, 0x48, // 1cf0 + 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xca, 0xe4, 0x19, // 1cf8 + 0x08, 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, // 1d00 + 0xca, 0xe4, 0x19, 0x08, 0xe0, 0x7e, 0xd0, 0xfe, // 1d08 + 0x68, 0x48, 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa9, // 1d10 + 0x00, 0x48, 0xa2, 0x80, 0x28, 0xec, 0x1c, 0x02, // 1d18 + 0x08, 0x68, 0x48, 0xc9, 0x31, 0xd0, 0xfe, 0x28, // 1d20 + 0xca, 0xec, 0x1c, 0x02, 0x08, 0x68, 0x48, 0xc9, // 1d28 + 0x33, 0xd0, 0xfe, 0x28, 0xca, 0xec, 0x1c, 0x02, // 1d30 + 0x08, 0xe0, 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1d38 + 0xb0, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa2, // 1d40 + 0x80, 0x28, 0xec, 0x1c, 0x02, 0x08, 0x68, 0x48, // 1d48 + 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xca, 0xec, 0x1c, // 1d50 + 0x02, 0x08, 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, // 1d58 + 0x28, 0xca, 0xec, 0x1c, 0x02, 0x08, 0xe0, 0x7e, // 1d60 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfc, 0xd0, 0xfe, // 1d68 + 0x28, 0xa9, 0x00, 0x48, 0xa2, 0x80, 0x28, 0xe0, // 1d70 + 0x7f, 0x08, 0x68, 0x48, 0xc9, 0x31, 0xd0, 0xfe, // 1d78 + 0x28, 0xca, 0xe0, 0x7f, 0x08, 0x68, 0x48, 0xc9, // 1d80 + 0x33, 0xd0, 0xfe, 0x28, 0xca, 0xe0, 0x7f, 0x08, // 1d88 + 0xe0, 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, // 1d90 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa2, 0x80, // 1d98 + 0x28, 0xe0, 0x7f, 0x08, 0x68, 0x48, 0xc9, 0x7d, // 1da0 + 0xd0, 0xfe, 0x28, 0xca, 0xe0, 0x7f, 0x08, 0x68, // 1da8 + 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, 0xca, 0xe0, // 1db0 + 0x7f, 0x08, 0xe0, 0x7e, 0xd0, 0xfe, 0x68, 0x48, // 1db8 + 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xad, 0x00, 0x02, // 1dc0 + 0xc9, 0x1a, 0xd0, 0xfe, 0xa9, 0x1b, 0x8d, 0x00, // 1dc8 + 0x02, 0xa9, 0x00, 0x48, 0xa0, 0x80, 0x28, 0xc4, // 1dd0 + 0x19, 0x08, 0x68, 0x48, 0xc9, 0x31, 0xd0, 0xfe, // 1dd8 + 0x28, 0x88, 0xc4, 0x19, 0x08, 0x68, 0x48, 0xc9, // 1de0 + 0x33, 0xd0, 0xfe, 0x28, 0x88, 0xc4, 0x19, 0x08, // 1de8 + 0xc0, 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, // 1df0 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa0, 0x80, // 1df8 + 0x28, 0xc4, 0x19, 0x08, 0x68, 0x48, 0xc9, 0x7d, // 1e00 + 0xd0, 0xfe, 0x28, 0x88, 0xc4, 0x19, 0x08, 0x68, // 1e08 + 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, 0x88, 0xc4, // 1e10 + 0x19, 0x08, 0xc0, 0x7e, 0xd0, 0xfe, 0x68, 0x48, // 1e18 + 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, // 1e20 + 0xa0, 0x80, 0x28, 0xcc, 0x1c, 0x02, 0x08, 0x68, // 1e28 + 0x48, 0xc9, 0x31, 0xd0, 0xfe, 0x28, 0x88, 0xcc, // 1e30 + 0x1c, 0x02, 0x08, 0x68, 0x48, 0xc9, 0x33, 0xd0, // 1e38 + 0xfe, 0x28, 0x88, 0xcc, 0x1c, 0x02, 0x08, 0xc0, // 1e40 + 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, // 1e48 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa0, 0x80, 0x28, // 1e50 + 0xcc, 0x1c, 0x02, 0x08, 0x68, 0x48, 0xc9, 0x7d, // 1e58 + 0xd0, 0xfe, 0x28, 0x88, 0xcc, 0x1c, 0x02, 0x08, // 1e60 + 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, 0x88, // 1e68 + 0xcc, 0x1c, 0x02, 0x08, 0xc0, 0x7e, 0xd0, 0xfe, // 1e70 + 0x68, 0x48, 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa9, // 1e78 + 0x00, 0x48, 0xa0, 0x80, 0x28, 0xc0, 0x7f, 0x08, // 1e80 + 0x68, 0x48, 0xc9, 0x31, 0xd0, 0xfe, 0x28, 0x88, // 1e88 + 0xc0, 0x7f, 0x08, 0x68, 0x48, 0xc9, 0x33, 0xd0, // 1e90 + 0xfe, 0x28, 0x88, 0xc0, 0x7f, 0x08, 0xc0, 0x7e, // 1e98 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, 0xfe, // 1ea0 + 0x28, 0xa9, 0xff, 0x48, 0xa0, 0x80, 0x28, 0xc0, // 1ea8 + 0x7f, 0x08, 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, // 1eb0 + 0x28, 0x88, 0xc0, 0x7f, 0x08, 0x68, 0x48, 0xc9, // 1eb8 + 0x7f, 0xd0, 0xfe, 0x28, 0x88, 0xc0, 0x7f, 0x08, // 1ec0 + 0xc0, 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfc, // 1ec8 + 0xd0, 0xfe, 0x28, 0xad, 0x00, 0x02, 0xc9, 0x1b, // 1ed0 + 0xd0, 0xfe, 0xa9, 0x1c, 0x8d, 0x00, 0x02, 0xa9, // 1ed8 + 0x00, 0x48, 0xa9, 0x80, 0x28, 0xc5, 0x19, 0x08, // 1ee0 + 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x31, // 1ee8 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7f, // 1ef0 + 0x28, 0xc5, 0x19, 0x08, 0xc9, 0x7f, 0xd0, 0xfe, // 1ef8 + 0x68, 0x48, 0xc9, 0x33, 0xd0, 0xfe, 0x28, 0xa9, // 1f00 + 0x00, 0x48, 0xa9, 0x7e, 0x28, 0xc5, 0x19, 0x08, // 1f08 + 0xc9, 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, // 1f10 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x80, // 1f18 + 0x28, 0xc5, 0x19, 0x08, 0xc9, 0x80, 0xd0, 0xfe, // 1f20 + 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, // 1f28 + 0xff, 0x48, 0xa9, 0x7f, 0x28, 0xc5, 0x19, 0x08, // 1f30 + 0xc9, 0x7f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, // 1f38 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7e, // 1f40 + 0x28, 0xc5, 0x19, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, // 1f48 + 0x68, 0x48, 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa9, // 1f50 + 0x00, 0x48, 0xa9, 0x80, 0x28, 0xcd, 0x1c, 0x02, // 1f58 + 0x08, 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1f60 + 0x31, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, // 1f68 + 0x7f, 0x28, 0xcd, 0x1c, 0x02, 0x08, 0xc9, 0x7f, // 1f70 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x33, 0xd0, 0xfe, // 1f78 + 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7e, 0x28, 0xcd, // 1f80 + 0x1c, 0x02, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, 0x68, // 1f88 + 0x48, 0xc9, 0xb0, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 1f90 + 0x48, 0xa9, 0x80, 0x28, 0xcd, 0x1c, 0x02, 0x08, // 1f98 + 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7d, // 1fa0 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7f, // 1fa8 + 0x28, 0xcd, 0x1c, 0x02, 0x08, 0xc9, 0x7f, 0xd0, // 1fb0 + 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, // 1fb8 + 0xa9, 0xff, 0x48, 0xa9, 0x7e, 0x28, 0xcd, 0x1c, // 1fc0 + 0x02, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, 0x68, 0x48, // 1fc8 + 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, // 1fd0 + 0xa9, 0x80, 0x28, 0xc9, 0x7f, 0x08, 0xc9, 0x80, // 1fd8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x31, 0xd0, 0xfe, // 1fe0 + 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7f, 0x28, 0xc9, // 1fe8 + 0x7f, 0x08, 0xc9, 0x7f, 0xd0, 0xfe, 0x68, 0x48, // 1ff0 + 0xc9, 0x33, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, // 1ff8 + 0xa9, 0x7e, 0x28, 0xc9, 0x7f, 0x08, 0xc9, 0x7e, // 2000 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, 0xfe, // 2008 + 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x80, 0x28, 0xc9, // 2010 + 0x7f, 0x08, 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, // 2018 + 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, // 2020 + 0xa9, 0x7f, 0x28, 0xc9, 0x7f, 0x08, 0xc9, 0x7f, // 2028 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, // 2030 + 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7e, 0x28, 0xc9, // 2038 + 0x7f, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, 0x68, 0x48, // 2040 + 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa2, 0x04, 0xa9, // 2048 + 0x00, 0x48, 0xa9, 0x80, 0x28, 0xd5, 0x15, 0x08, // 2050 + 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x31, // 2058 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7f, // 2060 + 0x28, 0xd5, 0x15, 0x08, 0xc9, 0x7f, 0xd0, 0xfe, // 2068 + 0x68, 0x48, 0xc9, 0x33, 0xd0, 0xfe, 0x28, 0xa9, // 2070 + 0x00, 0x48, 0xa9, 0x7e, 0x28, 0xd5, 0x15, 0x08, // 2078 + 0xc9, 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, // 2080 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x80, // 2088 + 0x28, 0xd5, 0x15, 0x08, 0xc9, 0x80, 0xd0, 0xfe, // 2090 + 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, // 2098 + 0xff, 0x48, 0xa9, 0x7f, 0x28, 0xd5, 0x15, 0x08, // 20a0 + 0xc9, 0x7f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, // 20a8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7e, // 20b0 + 0x28, 0xd5, 0x15, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, // 20b8 + 0x68, 0x48, 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa9, // 20c0 + 0x00, 0x48, 0xa9, 0x80, 0x28, 0xdd, 0x18, 0x02, // 20c8 + 0x08, 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 20d0 + 0x31, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, // 20d8 + 0x7f, 0x28, 0xdd, 0x18, 0x02, 0x08, 0xc9, 0x7f, // 20e0 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x33, 0xd0, 0xfe, // 20e8 + 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7e, 0x28, 0xdd, // 20f0 + 0x18, 0x02, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, 0x68, // 20f8 + 0x48, 0xc9, 0xb0, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 2100 + 0x48, 0xa9, 0x80, 0x28, 0xdd, 0x18, 0x02, 0x08, // 2108 + 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7d, // 2110 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7f, // 2118 + 0x28, 0xdd, 0x18, 0x02, 0x08, 0xc9, 0x7f, 0xd0, // 2120 + 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, // 2128 + 0xa9, 0xff, 0x48, 0xa9, 0x7e, 0x28, 0xdd, 0x18, // 2130 + 0x02, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, 0x68, 0x48, // 2138 + 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa0, 0x04, 0xa2, // 2140 + 0x08, 0xa9, 0x00, 0x48, 0xa9, 0x80, 0x28, 0xd9, // 2148 + 0x18, 0x02, 0x08, 0xc9, 0x80, 0xd0, 0xfe, 0x68, // 2150 + 0x48, 0xc9, 0x31, 0xd0, 0xfe, 0x28, 0xa9, 0x00, // 2158 + 0x48, 0xa9, 0x7f, 0x28, 0xd9, 0x18, 0x02, 0x08, // 2160 + 0xc9, 0x7f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x33, // 2168 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7e, // 2170 + 0x28, 0xd9, 0x18, 0x02, 0x08, 0xc9, 0x7e, 0xd0, // 2178 + 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, 0xfe, 0x28, // 2180 + 0xa9, 0xff, 0x48, 0xa9, 0x80, 0x28, 0xd9, 0x18, // 2188 + 0x02, 0x08, 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, // 2190 + 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, // 2198 + 0xa9, 0x7f, 0x28, 0xd9, 0x18, 0x02, 0x08, 0xc9, // 21a0 + 0x7f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, // 21a8 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7e, 0x28, // 21b0 + 0xd9, 0x18, 0x02, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, // 21b8 + 0x68, 0x48, 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa9, // 21c0 + 0x00, 0x48, 0xa9, 0x80, 0x28, 0xc1, 0x26, 0x08, // 21c8 + 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x31, // 21d0 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7f, // 21d8 + 0x28, 0xc1, 0x26, 0x08, 0xc9, 0x7f, 0xd0, 0xfe, // 21e0 + 0x68, 0x48, 0xc9, 0x33, 0xd0, 0xfe, 0x28, 0xa9, // 21e8 + 0x00, 0x48, 0xa9, 0x7e, 0x28, 0xc1, 0x26, 0x08, // 21f0 + 0xc9, 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, // 21f8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x80, // 2200 + 0x28, 0xc1, 0x26, 0x08, 0xc9, 0x80, 0xd0, 0xfe, // 2208 + 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, // 2210 + 0xff, 0x48, 0xa9, 0x7f, 0x28, 0xc1, 0x26, 0x08, // 2218 + 0xc9, 0x7f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, // 2220 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7e, // 2228 + 0x28, 0xc1, 0x26, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, // 2230 + 0x68, 0x48, 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xa9, // 2238 + 0x00, 0x48, 0xa9, 0x80, 0x28, 0xd1, 0x26, 0x08, // 2240 + 0xc9, 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x31, // 2248 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7f, // 2250 + 0x28, 0xd1, 0x26, 0x08, 0xc9, 0x7f, 0xd0, 0xfe, // 2258 + 0x68, 0x48, 0xc9, 0x33, 0xd0, 0xfe, 0x28, 0xa9, // 2260 + 0x00, 0x48, 0xa9, 0x7e, 0x28, 0xd1, 0x26, 0x08, // 2268 + 0xc9, 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, // 2270 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x80, // 2278 + 0x28, 0xd1, 0x26, 0x08, 0xc9, 0x80, 0xd0, 0xfe, // 2280 + 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, // 2288 + 0xff, 0x48, 0xa9, 0x7f, 0x28, 0xd1, 0x26, 0x08, // 2290 + 0xc9, 0x7f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, // 2298 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7e, // 22a0 + 0x28, 0xd1, 0x26, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, // 22a8 + 0x68, 0x48, 0xc9, 0xfc, 0xd0, 0xfe, 0x28, 0xad, // 22b0 + 0x00, 0x02, 0xc9, 0x1c, 0xd0, 0xfe, 0xa9, 0x1d, // 22b8 + 0x8d, 0x00, 0x02, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 22c0 + 0xb5, 0x13, 0x28, 0x0a, 0x08, 0xdd, 0x21, 0x02, // 22c8 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x39, 0x02, // 22d0 + 0xd0, 0xfe, 0xca, 0x10, 0xe8, 0xa2, 0x05, 0xa9, // 22d8 + 0xff, 0x48, 0xb5, 0x13, 0x28, 0x0a, 0x08, 0xdd, // 22e0 + 0x21, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 22e8 + 0x39, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe8, 0xa2, // 22f0 + 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, 0x28, 0x4a, // 22f8 + 0x08, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2300 + 0x30, 0xdd, 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2308 + 0xe8, 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, // 2310 + 0x28, 0x4a, 0x08, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, // 2318 + 0x68, 0x49, 0x7c, 0xdd, 0x45, 0x02, 0xd0, 0xfe, // 2320 + 0xca, 0x10, 0xe8, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 2328 + 0xb5, 0x13, 0x28, 0x2a, 0x08, 0xdd, 0x21, 0x02, // 2330 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x39, 0x02, // 2338 + 0xd0, 0xfe, 0xca, 0x10, 0xe8, 0xa2, 0x05, 0xa9, // 2340 + 0xfe, 0x48, 0xb5, 0x13, 0x28, 0x2a, 0x08, 0xdd, // 2348 + 0x21, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 2350 + 0x39, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe8, 0xa2, // 2358 + 0x05, 0xa9, 0x01, 0x48, 0xb5, 0x13, 0x28, 0x2a, // 2360 + 0x08, 0xdd, 0x27, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2368 + 0x30, 0xdd, 0x3f, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2370 + 0xe8, 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, // 2378 + 0x28, 0x2a, 0x08, 0xdd, 0x27, 0x02, 0xd0, 0xfe, // 2380 + 0x68, 0x49, 0x7c, 0xdd, 0x3f, 0x02, 0xd0, 0xfe, // 2388 + 0xca, 0x10, 0xe8, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 2390 + 0xb5, 0x13, 0x28, 0x6a, 0x08, 0xdd, 0x2d, 0x02, // 2398 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x45, 0x02, // 23a0 + 0xd0, 0xfe, 0xca, 0x10, 0xe8, 0xa2, 0x05, 0xa9, // 23a8 + 0xfe, 0x48, 0xb5, 0x13, 0x28, 0x6a, 0x08, 0xdd, // 23b0 + 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 23b8 + 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe8, 0xa2, // 23c0 + 0x05, 0xa9, 0x01, 0x48, 0xb5, 0x13, 0x28, 0x6a, // 23c8 + 0x08, 0xdd, 0x33, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 23d0 + 0x30, 0xdd, 0x4b, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 23d8 + 0xe8, 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, // 23e0 + 0x28, 0x6a, 0x08, 0xdd, 0x33, 0x02, 0xd0, 0xfe, // 23e8 + 0x68, 0x49, 0x7c, 0xdd, 0x4b, 0x02, 0xd0, 0xfe, // 23f0 + 0xca, 0x10, 0xe8, 0xad, 0x00, 0x02, 0xc9, 0x1d, // 23f8 + 0xd0, 0xfe, 0xa9, 0x1e, 0x8d, 0x00, 0x02, 0xa2, // 2400 + 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, 0x85, 0x0c, // 2408 + 0x28, 0x06, 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x21, // 2410 + 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x39, // 2418 + 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, // 2420 + 0xa9, 0xff, 0x48, 0xb5, 0x13, 0x85, 0x0c, 0x28, // 2428 + 0x06, 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x21, 0x02, // 2430 + 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, 0x39, 0x02, // 2438 + 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, 0xa9, // 2440 + 0x00, 0x48, 0xb5, 0x13, 0x85, 0x0c, 0x28, 0x46, // 2448 + 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x2d, 0x02, 0xd0, // 2450 + 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x45, 0x02, 0xd0, // 2458 + 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, 0xa9, 0xff, // 2460 + 0x48, 0xb5, 0x13, 0x85, 0x0c, 0x28, 0x46, 0x0c, // 2468 + 0x08, 0xa5, 0x0c, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, // 2470 + 0x68, 0x49, 0x7c, 0xdd, 0x45, 0x02, 0xd0, 0xfe, // 2478 + 0xca, 0x10, 0xe3, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 2480 + 0xb5, 0x13, 0x85, 0x0c, 0x28, 0x26, 0x0c, 0x08, // 2488 + 0xa5, 0x0c, 0xdd, 0x21, 0x02, 0xd0, 0xfe, 0x68, // 2490 + 0x49, 0x30, 0xdd, 0x39, 0x02, 0xd0, 0xfe, 0xca, // 2498 + 0x10, 0xe3, 0xa2, 0x05, 0xa9, 0xfe, 0x48, 0xb5, // 24a0 + 0x13, 0x85, 0x0c, 0x28, 0x26, 0x0c, 0x08, 0xa5, // 24a8 + 0x0c, 0xdd, 0x21, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 24b0 + 0x7c, 0xdd, 0x39, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 24b8 + 0xe3, 0xa2, 0x05, 0xa9, 0x01, 0x48, 0xb5, 0x13, // 24c0 + 0x85, 0x0c, 0x28, 0x26, 0x0c, 0x08, 0xa5, 0x0c, // 24c8 + 0xdd, 0x27, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 24d0 + 0xdd, 0x3f, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, // 24d8 + 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, 0x85, // 24e0 + 0x0c, 0x28, 0x26, 0x0c, 0x08, 0xa5, 0x0c, 0xdd, // 24e8 + 0x27, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 24f0 + 0x3f, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xa2, // 24f8 + 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, 0x85, 0x0c, // 2500 + 0x28, 0x66, 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x2d, // 2508 + 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x45, // 2510 + 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, // 2518 + 0xa9, 0xfe, 0x48, 0xb5, 0x13, 0x85, 0x0c, 0x28, // 2520 + 0x66, 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x2d, 0x02, // 2528 + 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, 0x45, 0x02, // 2530 + 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, 0xa9, // 2538 + 0x01, 0x48, 0xb5, 0x13, 0x85, 0x0c, 0x28, 0x66, // 2540 + 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x33, 0x02, 0xd0, // 2548 + 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x4b, 0x02, 0xd0, // 2550 + 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, 0xa9, 0xff, // 2558 + 0x48, 0xb5, 0x13, 0x85, 0x0c, 0x28, 0x66, 0x0c, // 2560 + 0x08, 0xa5, 0x0c, 0xdd, 0x33, 0x02, 0xd0, 0xfe, // 2568 + 0x68, 0x49, 0x7c, 0xdd, 0x4b, 0x02, 0xd0, 0xfe, // 2570 + 0xca, 0x10, 0xe3, 0xad, 0x00, 0x02, 0xc9, 0x1e, // 2578 + 0xd0, 0xfe, 0xa9, 0x1f, 0x8d, 0x00, 0x02, 0xa2, // 2580 + 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, 0x8d, 0x03, // 2588 + 0x02, 0x28, 0x0e, 0x03, 0x02, 0x08, 0xad, 0x03, // 2590 + 0x02, 0xdd, 0x21, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2598 + 0x30, 0xdd, 0x39, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 25a0 + 0xe0, 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, // 25a8 + 0x8d, 0x03, 0x02, 0x28, 0x0e, 0x03, 0x02, 0x08, // 25b0 + 0xad, 0x03, 0x02, 0xdd, 0x21, 0x02, 0xd0, 0xfe, // 25b8 + 0x68, 0x49, 0x7c, 0xdd, 0x39, 0x02, 0xd0, 0xfe, // 25c0 + 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 25c8 + 0xb5, 0x13, 0x8d, 0x03, 0x02, 0x28, 0x4e, 0x03, // 25d0 + 0x02, 0x08, 0xad, 0x03, 0x02, 0xdd, 0x2d, 0x02, // 25d8 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x45, 0x02, // 25e0 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, // 25e8 + 0xff, 0x48, 0xb5, 0x13, 0x8d, 0x03, 0x02, 0x28, // 25f0 + 0x4e, 0x03, 0x02, 0x08, 0xad, 0x03, 0x02, 0xdd, // 25f8 + 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 2600 + 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, // 2608 + 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, 0x8d, 0x03, // 2610 + 0x02, 0x28, 0x2e, 0x03, 0x02, 0x08, 0xad, 0x03, // 2618 + 0x02, 0xdd, 0x21, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2620 + 0x30, 0xdd, 0x39, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2628 + 0xe0, 0xa2, 0x05, 0xa9, 0xfe, 0x48, 0xb5, 0x13, // 2630 + 0x8d, 0x03, 0x02, 0x28, 0x2e, 0x03, 0x02, 0x08, // 2638 + 0xad, 0x03, 0x02, 0xdd, 0x21, 0x02, 0xd0, 0xfe, // 2640 + 0x68, 0x49, 0x7c, 0xdd, 0x39, 0x02, 0xd0, 0xfe, // 2648 + 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, 0x01, 0x48, // 2650 + 0xb5, 0x13, 0x8d, 0x03, 0x02, 0x28, 0x2e, 0x03, // 2658 + 0x02, 0x08, 0xad, 0x03, 0x02, 0xdd, 0x27, 0x02, // 2660 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x3f, 0x02, // 2668 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, // 2670 + 0xff, 0x48, 0xb5, 0x13, 0x8d, 0x03, 0x02, 0x28, // 2678 + 0x2e, 0x03, 0x02, 0x08, 0xad, 0x03, 0x02, 0xdd, // 2680 + 0x27, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 2688 + 0x3f, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, // 2690 + 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, 0x8d, 0x03, // 2698 + 0x02, 0x28, 0x6e, 0x03, 0x02, 0x08, 0xad, 0x03, // 26a0 + 0x02, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 26a8 + 0x30, 0xdd, 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 26b0 + 0xe0, 0xa2, 0x05, 0xa9, 0xfe, 0x48, 0xb5, 0x13, // 26b8 + 0x8d, 0x03, 0x02, 0x28, 0x6e, 0x03, 0x02, 0x08, // 26c0 + 0xad, 0x03, 0x02, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, // 26c8 + 0x68, 0x49, 0x7c, 0xdd, 0x45, 0x02, 0xd0, 0xfe, // 26d0 + 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, 0x01, 0x48, // 26d8 + 0xb5, 0x13, 0x8d, 0x03, 0x02, 0x28, 0x6e, 0x03, // 26e0 + 0x02, 0x08, 0xad, 0x03, 0x02, 0xdd, 0x33, 0x02, // 26e8 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x4b, 0x02, // 26f0 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, // 26f8 + 0xff, 0x48, 0xb5, 0x13, 0x8d, 0x03, 0x02, 0x28, // 2700 + 0x6e, 0x03, 0x02, 0x08, 0xad, 0x03, 0x02, 0xdd, // 2708 + 0x33, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 2710 + 0x4b, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xad, // 2718 + 0x00, 0x02, 0xc9, 0x1f, 0xd0, 0xfe, 0xa9, 0x20, // 2720 + 0x8d, 0x00, 0x02, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 2728 + 0xb5, 0x13, 0x95, 0x0c, 0x28, 0x16, 0x0c, 0x08, // 2730 + 0xb5, 0x0c, 0xdd, 0x21, 0x02, 0xd0, 0xfe, 0x68, // 2738 + 0x49, 0x30, 0xdd, 0x39, 0x02, 0xd0, 0xfe, 0xca, // 2740 + 0x10, 0xe3, 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, // 2748 + 0x13, 0x95, 0x0c, 0x28, 0x16, 0x0c, 0x08, 0xb5, // 2750 + 0x0c, 0xdd, 0x21, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2758 + 0x7c, 0xdd, 0x39, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2760 + 0xe3, 0xa2, 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, // 2768 + 0x95, 0x0c, 0x28, 0x56, 0x0c, 0x08, 0xb5, 0x0c, // 2770 + 0xdd, 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 2778 + 0xdd, 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, // 2780 + 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, 0x95, // 2788 + 0x0c, 0x28, 0x56, 0x0c, 0x08, 0xb5, 0x0c, 0xdd, // 2790 + 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 2798 + 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xa2, // 27a0 + 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, 0x95, 0x0c, // 27a8 + 0x28, 0x36, 0x0c, 0x08, 0xb5, 0x0c, 0xdd, 0x21, // 27b0 + 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x39, // 27b8 + 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, // 27c0 + 0xa9, 0xfe, 0x48, 0xb5, 0x13, 0x95, 0x0c, 0x28, // 27c8 + 0x36, 0x0c, 0x08, 0xb5, 0x0c, 0xdd, 0x21, 0x02, // 27d0 + 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, 0x39, 0x02, // 27d8 + 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, 0xa9, // 27e0 + 0x01, 0x48, 0xb5, 0x13, 0x95, 0x0c, 0x28, 0x36, // 27e8 + 0x0c, 0x08, 0xb5, 0x0c, 0xdd, 0x27, 0x02, 0xd0, // 27f0 + 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x3f, 0x02, 0xd0, // 27f8 + 0xfe, 0xca, 0x10, 0xe3, 0xa2, 0x05, 0xa9, 0xff, // 2800 + 0x48, 0xb5, 0x13, 0x95, 0x0c, 0x28, 0x36, 0x0c, // 2808 + 0x08, 0xb5, 0x0c, 0xdd, 0x27, 0x02, 0xd0, 0xfe, // 2810 + 0x68, 0x49, 0x7c, 0xdd, 0x3f, 0x02, 0xd0, 0xfe, // 2818 + 0xca, 0x10, 0xe3, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 2820 + 0xb5, 0x13, 0x95, 0x0c, 0x28, 0x76, 0x0c, 0x08, // 2828 + 0xb5, 0x0c, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, 0x68, // 2830 + 0x49, 0x30, 0xdd, 0x45, 0x02, 0xd0, 0xfe, 0xca, // 2838 + 0x10, 0xe3, 0xa2, 0x05, 0xa9, 0xfe, 0x48, 0xb5, // 2840 + 0x13, 0x95, 0x0c, 0x28, 0x76, 0x0c, 0x08, 0xb5, // 2848 + 0x0c, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2850 + 0x7c, 0xdd, 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2858 + 0xe3, 0xa2, 0x05, 0xa9, 0x01, 0x48, 0xb5, 0x13, // 2860 + 0x95, 0x0c, 0x28, 0x76, 0x0c, 0x08, 0xb5, 0x0c, // 2868 + 0xdd, 0x33, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 2870 + 0xdd, 0x4b, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, // 2878 + 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, 0x95, // 2880 + 0x0c, 0x28, 0x76, 0x0c, 0x08, 0xb5, 0x0c, 0xdd, // 2888 + 0x33, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 2890 + 0x4b, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe3, 0xad, // 2898 + 0x00, 0x02, 0xc9, 0x20, 0xd0, 0xfe, 0xa9, 0x21, // 28a0 + 0x8d, 0x00, 0x02, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 28a8 + 0xb5, 0x13, 0x9d, 0x03, 0x02, 0x28, 0x1e, 0x03, // 28b0 + 0x02, 0x08, 0xbd, 0x03, 0x02, 0xdd, 0x21, 0x02, // 28b8 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x39, 0x02, // 28c0 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, // 28c8 + 0xff, 0x48, 0xb5, 0x13, 0x9d, 0x03, 0x02, 0x28, // 28d0 + 0x1e, 0x03, 0x02, 0x08, 0xbd, 0x03, 0x02, 0xdd, // 28d8 + 0x21, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 28e0 + 0x39, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, // 28e8 + 0x05, 0xa9, 0x00, 0x48, 0xb5, 0x13, 0x9d, 0x03, // 28f0 + 0x02, 0x28, 0x5e, 0x03, 0x02, 0x08, 0xbd, 0x03, // 28f8 + 0x02, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2900 + 0x30, 0xdd, 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2908 + 0xe0, 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, // 2910 + 0x9d, 0x03, 0x02, 0x28, 0x5e, 0x03, 0x02, 0x08, // 2918 + 0xbd, 0x03, 0x02, 0xdd, 0x2d, 0x02, 0xd0, 0xfe, // 2920 + 0x68, 0x49, 0x7c, 0xdd, 0x45, 0x02, 0xd0, 0xfe, // 2928 + 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 2930 + 0xb5, 0x13, 0x9d, 0x03, 0x02, 0x28, 0x3e, 0x03, // 2938 + 0x02, 0x08, 0xbd, 0x03, 0x02, 0xdd, 0x21, 0x02, // 2940 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x39, 0x02, // 2948 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, // 2950 + 0xfe, 0x48, 0xb5, 0x13, 0x9d, 0x03, 0x02, 0x28, // 2958 + 0x3e, 0x03, 0x02, 0x08, 0xbd, 0x03, 0x02, 0xdd, // 2960 + 0x21, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 2968 + 0x39, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, // 2970 + 0x05, 0xa9, 0x01, 0x48, 0xb5, 0x13, 0x9d, 0x03, // 2978 + 0x02, 0x28, 0x3e, 0x03, 0x02, 0x08, 0xbd, 0x03, // 2980 + 0x02, 0xdd, 0x27, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2988 + 0x30, 0xdd, 0x3f, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2990 + 0xe0, 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, // 2998 + 0x9d, 0x03, 0x02, 0x28, 0x3e, 0x03, 0x02, 0x08, // 29a0 + 0xbd, 0x03, 0x02, 0xdd, 0x27, 0x02, 0xd0, 0xfe, // 29a8 + 0x68, 0x49, 0x7c, 0xdd, 0x3f, 0x02, 0xd0, 0xfe, // 29b0 + 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, 0x00, 0x48, // 29b8 + 0xb5, 0x13, 0x9d, 0x03, 0x02, 0x28, 0x7e, 0x03, // 29c0 + 0x02, 0x08, 0xbd, 0x03, 0x02, 0xdd, 0x2d, 0x02, // 29c8 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x45, 0x02, // 29d0 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x05, 0xa9, // 29d8 + 0xfe, 0x48, 0xb5, 0x13, 0x9d, 0x03, 0x02, 0x28, // 29e0 + 0x7e, 0x03, 0x02, 0x08, 0xbd, 0x03, 0x02, 0xdd, // 29e8 + 0x2d, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7c, 0xdd, // 29f0 + 0x45, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, // 29f8 + 0x05, 0xa9, 0x01, 0x48, 0xb5, 0x13, 0x9d, 0x03, // 2a00 + 0x02, 0x28, 0x7e, 0x03, 0x02, 0x08, 0xbd, 0x03, // 2a08 + 0x02, 0xdd, 0x33, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2a10 + 0x30, 0xdd, 0x4b, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2a18 + 0xe0, 0xa2, 0x05, 0xa9, 0xff, 0x48, 0xb5, 0x13, // 2a20 + 0x9d, 0x03, 0x02, 0x28, 0x7e, 0x03, 0x02, 0x08, // 2a28 + 0xbd, 0x03, 0x02, 0xdd, 0x33, 0x02, 0xd0, 0xfe, // 2a30 + 0x68, 0x49, 0x7c, 0xdd, 0x4b, 0x02, 0xd0, 0xfe, // 2a38 + 0xca, 0x10, 0xe0, 0xad, 0x00, 0x02, 0xc9, 0x21, // 2a40 + 0xd0, 0xfe, 0xa9, 0x22, 0x8d, 0x00, 0x02, 0xa2, // 2a48 + 0x00, 0xa9, 0x7e, 0x85, 0x0c, 0xa9, 0x00, 0x48, // 2a50 + 0x28, 0xe6, 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x51, // 2a58 + 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x56, // 2a60 + 0x02, 0xd0, 0xfe, 0xe8, 0xe0, 0x02, 0xd0, 0x04, // 2a68 + 0xa9, 0xfe, 0x85, 0x0c, 0xe0, 0x05, 0xd0, 0xdd, // 2a70 + 0xca, 0xe6, 0x0c, 0xa9, 0x00, 0x48, 0x28, 0xc6, // 2a78 + 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x51, 0x02, 0xd0, // 2a80 + 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x56, 0x02, 0xd0, // 2a88 + 0xfe, 0xca, 0x30, 0x0a, 0xe0, 0x01, 0xd0, 0xe3, // 2a90 + 0xa9, 0x81, 0x85, 0x0c, 0xd0, 0xdd, 0xa2, 0x00, // 2a98 + 0xa9, 0x7e, 0x85, 0x0c, 0xa9, 0xff, 0x48, 0x28, // 2aa0 + 0xe6, 0x0c, 0x08, 0xa5, 0x0c, 0xdd, 0x51, 0x02, // 2aa8 + 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xdd, 0x56, 0x02, // 2ab0 + 0xd0, 0xfe, 0xe8, 0xe0, 0x02, 0xd0, 0x04, 0xa9, // 2ab8 + 0xfe, 0x85, 0x0c, 0xe0, 0x05, 0xd0, 0xdd, 0xca, // 2ac0 + 0xe6, 0x0c, 0xa9, 0xff, 0x48, 0x28, 0xc6, 0x0c, // 2ac8 + 0x08, 0xa5, 0x0c, 0xdd, 0x51, 0x02, 0xd0, 0xfe, // 2ad0 + 0x68, 0x49, 0x7d, 0xdd, 0x56, 0x02, 0xd0, 0xfe, // 2ad8 + 0xca, 0x30, 0x0a, 0xe0, 0x01, 0xd0, 0xe3, 0xa9, // 2ae0 + 0x81, 0x85, 0x0c, 0xd0, 0xdd, 0xad, 0x00, 0x02, // 2ae8 + 0xc9, 0x22, 0xd0, 0xfe, 0xa9, 0x23, 0x8d, 0x00, // 2af0 + 0x02, 0xa2, 0x00, 0xa9, 0x7e, 0x8d, 0x03, 0x02, // 2af8 + 0xa9, 0x00, 0x48, 0x28, 0xee, 0x03, 0x02, 0x08, // 2b00 + 0xad, 0x03, 0x02, 0xdd, 0x51, 0x02, 0xd0, 0xfe, // 2b08 + 0x68, 0x49, 0x30, 0xdd, 0x56, 0x02, 0xd0, 0xfe, // 2b10 + 0xe8, 0xe0, 0x02, 0xd0, 0x05, 0xa9, 0xfe, 0x8d, // 2b18 + 0x03, 0x02, 0xe0, 0x05, 0xd0, 0xda, 0xca, 0xee, // 2b20 + 0x03, 0x02, 0xa9, 0x00, 0x48, 0x28, 0xce, 0x03, // 2b28 + 0x02, 0x08, 0xad, 0x03, 0x02, 0xdd, 0x51, 0x02, // 2b30 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x56, 0x02, // 2b38 + 0xd0, 0xfe, 0xca, 0x30, 0x0b, 0xe0, 0x01, 0xd0, // 2b40 + 0xe1, 0xa9, 0x81, 0x8d, 0x03, 0x02, 0xd0, 0xda, // 2b48 + 0xa2, 0x00, 0xa9, 0x7e, 0x8d, 0x03, 0x02, 0xa9, // 2b50 + 0xff, 0x48, 0x28, 0xee, 0x03, 0x02, 0x08, 0xad, // 2b58 + 0x03, 0x02, 0xdd, 0x51, 0x02, 0xd0, 0xfe, 0x68, // 2b60 + 0x49, 0x7d, 0xdd, 0x56, 0x02, 0xd0, 0xfe, 0xe8, // 2b68 + 0xe0, 0x02, 0xd0, 0x05, 0xa9, 0xfe, 0x8d, 0x03, // 2b70 + 0x02, 0xe0, 0x05, 0xd0, 0xda, 0xca, 0xee, 0x03, // 2b78 + 0x02, 0xa9, 0xff, 0x48, 0x28, 0xce, 0x03, 0x02, // 2b80 + 0x08, 0xad, 0x03, 0x02, 0xdd, 0x51, 0x02, 0xd0, // 2b88 + 0xfe, 0x68, 0x49, 0x7d, 0xdd, 0x56, 0x02, 0xd0, // 2b90 + 0xfe, 0xca, 0x30, 0x0b, 0xe0, 0x01, 0xd0, 0xe1, // 2b98 + 0xa9, 0x81, 0x8d, 0x03, 0x02, 0xd0, 0xda, 0xad, // 2ba0 + 0x00, 0x02, 0xc9, 0x23, 0xd0, 0xfe, 0xa9, 0x24, // 2ba8 + 0x8d, 0x00, 0x02, 0xa2, 0x00, 0xa9, 0x7e, 0x95, // 2bb0 + 0x0c, 0xa9, 0x00, 0x48, 0x28, 0xf6, 0x0c, 0x08, // 2bb8 + 0xb5, 0x0c, 0xdd, 0x51, 0x02, 0xd0, 0xfe, 0x68, // 2bc0 + 0x49, 0x30, 0xdd, 0x56, 0x02, 0xd0, 0xfe, 0xb5, // 2bc8 + 0x0c, 0xe8, 0xe0, 0x02, 0xd0, 0x02, 0xa9, 0xfe, // 2bd0 + 0xe0, 0x05, 0xd0, 0xdb, 0xca, 0xa9, 0x02, 0x95, // 2bd8 + 0x0c, 0xa9, 0x00, 0x48, 0x28, 0xd6, 0x0c, 0x08, // 2be0 + 0xb5, 0x0c, 0xdd, 0x51, 0x02, 0xd0, 0xfe, 0x68, // 2be8 + 0x49, 0x30, 0xdd, 0x56, 0x02, 0xd0, 0xfe, 0xb5, // 2bf0 + 0x0c, 0xca, 0x30, 0x08, 0xe0, 0x01, 0xd0, 0xdf, // 2bf8 + 0xa9, 0x81, 0xd0, 0xdb, 0xa2, 0x00, 0xa9, 0x7e, // 2c00 + 0x95, 0x0c, 0xa9, 0xff, 0x48, 0x28, 0xf6, 0x0c, // 2c08 + 0x08, 0xb5, 0x0c, 0xdd, 0x51, 0x02, 0xd0, 0xfe, // 2c10 + 0x68, 0x49, 0x7d, 0xdd, 0x56, 0x02, 0xd0, 0xfe, // 2c18 + 0xb5, 0x0c, 0xe8, 0xe0, 0x02, 0xd0, 0x02, 0xa9, // 2c20 + 0xfe, 0xe0, 0x05, 0xd0, 0xdb, 0xca, 0xa9, 0x02, // 2c28 + 0x95, 0x0c, 0xa9, 0xff, 0x48, 0x28, 0xd6, 0x0c, // 2c30 + 0x08, 0xb5, 0x0c, 0xdd, 0x51, 0x02, 0xd0, 0xfe, // 2c38 + 0x68, 0x49, 0x7d, 0xdd, 0x56, 0x02, 0xd0, 0xfe, // 2c40 + 0xb5, 0x0c, 0xca, 0x30, 0x08, 0xe0, 0x01, 0xd0, // 2c48 + 0xdf, 0xa9, 0x81, 0xd0, 0xdb, 0xad, 0x00, 0x02, // 2c50 + 0xc9, 0x24, 0xd0, 0xfe, 0xa9, 0x25, 0x8d, 0x00, // 2c58 + 0x02, 0xa2, 0x00, 0xa9, 0x7e, 0x9d, 0x03, 0x02, // 2c60 + 0xa9, 0x00, 0x48, 0x28, 0xfe, 0x03, 0x02, 0x08, // 2c68 + 0xbd, 0x03, 0x02, 0xdd, 0x51, 0x02, 0xd0, 0xfe, // 2c70 + 0x68, 0x49, 0x30, 0xdd, 0x56, 0x02, 0xd0, 0xfe, // 2c78 + 0xbd, 0x03, 0x02, 0xe8, 0xe0, 0x02, 0xd0, 0x02, // 2c80 + 0xa9, 0xfe, 0xe0, 0x05, 0xd0, 0xd7, 0xca, 0xa9, // 2c88 + 0x02, 0x9d, 0x03, 0x02, 0xa9, 0x00, 0x48, 0x28, // 2c90 + 0xde, 0x03, 0x02, 0x08, 0xbd, 0x03, 0x02, 0xdd, // 2c98 + 0x51, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, // 2ca0 + 0x56, 0x02, 0xd0, 0xfe, 0xbd, 0x03, 0x02, 0xca, // 2ca8 + 0x30, 0x08, 0xe0, 0x01, 0xd0, 0xdb, 0xa9, 0x81, // 2cb0 + 0xd0, 0xd7, 0xa2, 0x00, 0xa9, 0x7e, 0x9d, 0x03, // 2cb8 + 0x02, 0xa9, 0xff, 0x48, 0x28, 0xfe, 0x03, 0x02, // 2cc0 + 0x08, 0xbd, 0x03, 0x02, 0xdd, 0x51, 0x02, 0xd0, // 2cc8 + 0xfe, 0x68, 0x49, 0x7d, 0xdd, 0x56, 0x02, 0xd0, // 2cd0 + 0xfe, 0xbd, 0x03, 0x02, 0xe8, 0xe0, 0x02, 0xd0, // 2cd8 + 0x02, 0xa9, 0xfe, 0xe0, 0x05, 0xd0, 0xd7, 0xca, // 2ce0 + 0xa9, 0x02, 0x9d, 0x03, 0x02, 0xa9, 0xff, 0x48, // 2ce8 + 0x28, 0xde, 0x03, 0x02, 0x08, 0xbd, 0x03, 0x02, // 2cf0 + 0xdd, 0x51, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 2cf8 + 0xdd, 0x56, 0x02, 0xd0, 0xfe, 0xbd, 0x03, 0x02, // 2d00 + 0xca, 0x30, 0x08, 0xe0, 0x01, 0xd0, 0xdb, 0xa9, // 2d08 + 0x81, 0xd0, 0xd7, 0xad, 0x00, 0x02, 0xc9, 0x25, // 2d10 + 0xd0, 0xfe, 0xa9, 0x26, 0x8d, 0x00, 0x02, 0xa2, // 2d18 + 0x03, 0xb5, 0x1e, 0x8d, 0x0a, 0x02, 0xa9, 0x00, // 2d20 + 0x48, 0xbd, 0x6b, 0x02, 0x28, 0x20, 0x09, 0x02, // 2d28 + 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2d30 + 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2d38 + 0xe0, 0xa2, 0x03, 0xb5, 0x1e, 0x8d, 0x0a, 0x02, // 2d40 + 0xa9, 0xff, 0x48, 0xbd, 0x6b, 0x02, 0x28, 0x20, // 2d48 + 0x09, 0x02, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 2d50 + 0x68, 0x49, 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 2d58 + 0xca, 0x10, 0xe0, 0xa2, 0x03, 0xb5, 0x1e, 0x85, // 2d60 + 0x0c, 0xa9, 0x00, 0x48, 0xbd, 0x6b, 0x02, 0x28, // 2d68 + 0x25, 0x0c, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 2d70 + 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 2d78 + 0xca, 0x10, 0xe2, 0xa2, 0x03, 0xb5, 0x1e, 0x85, // 2d80 + 0x0c, 0xa9, 0xff, 0x48, 0xbd, 0x6b, 0x02, 0x28, // 2d88 + 0x25, 0x0c, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 2d90 + 0x68, 0x49, 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 2d98 + 0xca, 0x10, 0xe2, 0xa2, 0x03, 0xb5, 0x1e, 0x8d, // 2da0 + 0x03, 0x02, 0xa9, 0x00, 0x48, 0xbd, 0x6b, 0x02, // 2da8 + 0x28, 0x2d, 0x03, 0x02, 0x08, 0xdd, 0x73, 0x02, // 2db0 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, // 2db8 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x03, 0xb5, // 2dc0 + 0x1e, 0x8d, 0x03, 0x02, 0xa9, 0xff, 0x48, 0xbd, // 2dc8 + 0x6b, 0x02, 0x28, 0x2d, 0x03, 0x02, 0x08, 0xdd, // 2dd0 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xdd, // 2dd8 + 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0x02, 0xa2, // 2de0 + 0x03, 0xa9, 0x00, 0x48, 0xbd, 0x6b, 0x02, 0x28, // 2de8 + 0x35, 0x1e, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 2df0 + 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 2df8 + 0xca, 0x10, 0xe6, 0xa2, 0x03, 0xa9, 0xff, 0x48, // 2e00 + 0xbd, 0x6b, 0x02, 0x28, 0x35, 0x1e, 0x08, 0xdd, // 2e08 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xdd, // 2e10 + 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe6, 0xa2, // 2e18 + 0x03, 0xa9, 0x00, 0x48, 0xbd, 0x6b, 0x02, 0x28, // 2e20 + 0x3d, 0x5f, 0x02, 0x08, 0xdd, 0x73, 0x02, 0xd0, // 2e28 + 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, // 2e30 + 0xfe, 0xca, 0x10, 0xe5, 0xa2, 0x03, 0xa9, 0xff, // 2e38 + 0x48, 0xbd, 0x6b, 0x02, 0x28, 0x3d, 0x5f, 0x02, // 2e40 + 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2e48 + 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2e50 + 0xe5, 0xa0, 0x03, 0xa9, 0x00, 0x48, 0xb9, 0x6b, // 2e58 + 0x02, 0x28, 0x39, 0x5f, 0x02, 0x08, 0xd9, 0x73, // 2e60 + 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xd9, 0x77, // 2e68 + 0x02, 0xd0, 0xfe, 0x88, 0x10, 0xe5, 0xa0, 0x03, // 2e70 + 0xa9, 0xff, 0x48, 0xb9, 0x6b, 0x02, 0x28, 0x39, // 2e78 + 0x5f, 0x02, 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, // 2e80 + 0x68, 0x49, 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, // 2e88 + 0x88, 0x10, 0xe5, 0xa2, 0x06, 0xa0, 0x03, 0xa9, // 2e90 + 0x00, 0x48, 0xb9, 0x6b, 0x02, 0x28, 0x21, 0x3c, // 2e98 + 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2ea0 + 0x30, 0xd9, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0xca, // 2ea8 + 0x88, 0x10, 0xe4, 0xa2, 0x06, 0xa0, 0x03, 0xa9, // 2eb0 + 0xff, 0x48, 0xb9, 0x6b, 0x02, 0x28, 0x21, 0x3c, // 2eb8 + 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2ec0 + 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0xca, // 2ec8 + 0x88, 0x10, 0xe4, 0xa0, 0x03, 0xa9, 0x00, 0x48, // 2ed0 + 0xb9, 0x6b, 0x02, 0x28, 0x31, 0x3c, 0x08, 0xd9, // 2ed8 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xd9, // 2ee0 + 0x77, 0x02, 0xd0, 0xfe, 0x88, 0x10, 0xe6, 0xa0, // 2ee8 + 0x03, 0xa9, 0xff, 0x48, 0xb9, 0x6b, 0x02, 0x28, // 2ef0 + 0x31, 0x3c, 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, // 2ef8 + 0x68, 0x49, 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, // 2f00 + 0x88, 0x10, 0xe6, 0xad, 0x00, 0x02, 0xc9, 0x26, // 2f08 + 0xd0, 0xfe, 0xa9, 0x27, 0x8d, 0x00, 0x02, 0xa2, // 2f10 + 0x03, 0xb5, 0x22, 0x8d, 0x0d, 0x02, 0xa9, 0x00, // 2f18 + 0x48, 0xbd, 0x6f, 0x02, 0x28, 0x20, 0x0c, 0x02, // 2f20 + 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2f28 + 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 2f30 + 0xe0, 0xa2, 0x03, 0xb5, 0x22, 0x8d, 0x0d, 0x02, // 2f38 + 0xa9, 0xff, 0x48, 0xbd, 0x6f, 0x02, 0x28, 0x20, // 2f40 + 0x0c, 0x02, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 2f48 + 0x68, 0x49, 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 2f50 + 0xca, 0x10, 0xe0, 0xa2, 0x03, 0xb5, 0x22, 0x85, // 2f58 + 0x0c, 0xa9, 0x00, 0x48, 0xbd, 0x6f, 0x02, 0x28, // 2f60 + 0x45, 0x0c, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 2f68 + 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 2f70 + 0xca, 0x10, 0xe2, 0xa2, 0x03, 0xb5, 0x22, 0x85, // 2f78 + 0x0c, 0xa9, 0xff, 0x48, 0xbd, 0x6f, 0x02, 0x28, // 2f80 + 0x45, 0x0c, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 2f88 + 0x68, 0x49, 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 2f90 + 0xca, 0x10, 0xe2, 0xa2, 0x03, 0xb5, 0x22, 0x8d, // 2f98 + 0x03, 0x02, 0xa9, 0x00, 0x48, 0xbd, 0x6f, 0x02, // 2fa0 + 0x28, 0x4d, 0x03, 0x02, 0x08, 0xdd, 0x73, 0x02, // 2fa8 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, // 2fb0 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x03, 0xb5, // 2fb8 + 0x22, 0x8d, 0x03, 0x02, 0xa9, 0xff, 0x48, 0xbd, // 2fc0 + 0x6f, 0x02, 0x28, 0x4d, 0x03, 0x02, 0x08, 0xdd, // 2fc8 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xdd, // 2fd0 + 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0x02, 0xa2, // 2fd8 + 0x03, 0xa9, 0x00, 0x48, 0xbd, 0x6f, 0x02, 0x28, // 2fe0 + 0x55, 0x22, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 2fe8 + 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 2ff0 + 0xca, 0x10, 0xe6, 0xa2, 0x03, 0xa9, 0xff, 0x48, // 2ff8 + 0xbd, 0x6f, 0x02, 0x28, 0x55, 0x22, 0x08, 0xdd, // 3000 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xdd, // 3008 + 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe6, 0xa2, // 3010 + 0x03, 0xa9, 0x00, 0x48, 0xbd, 0x6f, 0x02, 0x28, // 3018 + 0x5d, 0x63, 0x02, 0x08, 0xdd, 0x73, 0x02, 0xd0, // 3020 + 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, // 3028 + 0xfe, 0xca, 0x10, 0xe5, 0xa2, 0x03, 0xa9, 0xff, // 3030 + 0x48, 0xbd, 0x6f, 0x02, 0x28, 0x5d, 0x63, 0x02, // 3038 + 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 3040 + 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 3048 + 0xe5, 0xa0, 0x03, 0xa9, 0x00, 0x48, 0xb9, 0x6f, // 3050 + 0x02, 0x28, 0x59, 0x63, 0x02, 0x08, 0xd9, 0x73, // 3058 + 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xd9, 0x77, // 3060 + 0x02, 0xd0, 0xfe, 0x88, 0x10, 0xe5, 0xa0, 0x03, // 3068 + 0xa9, 0xff, 0x48, 0xb9, 0x6f, 0x02, 0x28, 0x59, // 3070 + 0x63, 0x02, 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, // 3078 + 0x68, 0x49, 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, // 3080 + 0x88, 0x10, 0xe5, 0xa2, 0x06, 0xa0, 0x03, 0xa9, // 3088 + 0x00, 0x48, 0xb9, 0x6f, 0x02, 0x28, 0x41, 0x44, // 3090 + 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 3098 + 0x30, 0xd9, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0xca, // 30a0 + 0x88, 0x10, 0xe4, 0xa2, 0x06, 0xa0, 0x03, 0xa9, // 30a8 + 0xff, 0x48, 0xb9, 0x6f, 0x02, 0x28, 0x41, 0x44, // 30b0 + 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 30b8 + 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0xca, // 30c0 + 0x88, 0x10, 0xe4, 0xa0, 0x03, 0xa9, 0x00, 0x48, // 30c8 + 0xb9, 0x6f, 0x02, 0x28, 0x51, 0x44, 0x08, 0xd9, // 30d0 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xd9, // 30d8 + 0x77, 0x02, 0xd0, 0xfe, 0x88, 0x10, 0xe6, 0xa0, // 30e0 + 0x03, 0xa9, 0xff, 0x48, 0xb9, 0x6f, 0x02, 0x28, // 30e8 + 0x51, 0x44, 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, // 30f0 + 0x68, 0x49, 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, // 30f8 + 0x88, 0x10, 0xe6, 0xad, 0x00, 0x02, 0xc9, 0x27, // 3100 + 0xd0, 0xfe, 0xa9, 0x28, 0x8d, 0x00, 0x02, 0xa2, // 3108 + 0x03, 0xb5, 0x1a, 0x8d, 0x10, 0x02, 0xa9, 0x00, // 3110 + 0x48, 0xbd, 0x67, 0x02, 0x28, 0x20, 0x0f, 0x02, // 3118 + 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 3120 + 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 3128 + 0xe0, 0xa2, 0x03, 0xb5, 0x1a, 0x8d, 0x10, 0x02, // 3130 + 0xa9, 0xff, 0x48, 0xbd, 0x67, 0x02, 0x28, 0x20, // 3138 + 0x0f, 0x02, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 3140 + 0x68, 0x49, 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 3148 + 0xca, 0x10, 0xe0, 0xa2, 0x03, 0xb5, 0x1a, 0x85, // 3150 + 0x0c, 0xa9, 0x00, 0x48, 0xbd, 0x67, 0x02, 0x28, // 3158 + 0x05, 0x0c, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 3160 + 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 3168 + 0xca, 0x10, 0xe2, 0xa2, 0x03, 0xb5, 0x1a, 0x85, // 3170 + 0x0c, 0xa9, 0xff, 0x48, 0xbd, 0x67, 0x02, 0x28, // 3178 + 0x05, 0x0c, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 3180 + 0x68, 0x49, 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 3188 + 0xca, 0x10, 0xe2, 0xa2, 0x03, 0xb5, 0x1a, 0x8d, // 3190 + 0x03, 0x02, 0xa9, 0x00, 0x48, 0xbd, 0x67, 0x02, // 3198 + 0x28, 0x0d, 0x03, 0x02, 0x08, 0xdd, 0x73, 0x02, // 31a0 + 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, // 31a8 + 0xd0, 0xfe, 0xca, 0x10, 0xe0, 0xa2, 0x03, 0xb5, // 31b0 + 0x1a, 0x8d, 0x03, 0x02, 0xa9, 0xff, 0x48, 0xbd, // 31b8 + 0x67, 0x02, 0x28, 0x0d, 0x03, 0x02, 0x08, 0xdd, // 31c0 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xdd, // 31c8 + 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0x02, 0xa2, // 31d0 + 0x03, 0xa9, 0x00, 0x48, 0xbd, 0x67, 0x02, 0x28, // 31d8 + 0x15, 0x1a, 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, // 31e0 + 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, 0xfe, // 31e8 + 0xca, 0x10, 0xe6, 0xa2, 0x03, 0xa9, 0xff, 0x48, // 31f0 + 0xbd, 0x67, 0x02, 0x28, 0x15, 0x1a, 0x08, 0xdd, // 31f8 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xdd, // 3200 + 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, 0xe6, 0xa2, // 3208 + 0x03, 0xa9, 0x00, 0x48, 0xbd, 0x67, 0x02, 0x28, // 3210 + 0x1d, 0x5b, 0x02, 0x08, 0xdd, 0x73, 0x02, 0xd0, // 3218 + 0xfe, 0x68, 0x49, 0x30, 0xdd, 0x77, 0x02, 0xd0, // 3220 + 0xfe, 0xca, 0x10, 0xe5, 0xa2, 0x03, 0xa9, 0xff, // 3228 + 0x48, 0xbd, 0x67, 0x02, 0x28, 0x1d, 0x5b, 0x02, // 3230 + 0x08, 0xdd, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 3238 + 0x7d, 0xdd, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 3240 + 0xe5, 0xa0, 0x03, 0xa9, 0x00, 0x48, 0xb9, 0x67, // 3248 + 0x02, 0x28, 0x19, 0x5b, 0x02, 0x08, 0xd9, 0x73, // 3250 + 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xd9, 0x77, // 3258 + 0x02, 0xd0, 0xfe, 0x88, 0x10, 0xe5, 0xa0, 0x03, // 3260 + 0xa9, 0xff, 0x48, 0xb9, 0x67, 0x02, 0x28, 0x19, // 3268 + 0x5b, 0x02, 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, // 3270 + 0x68, 0x49, 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, // 3278 + 0x88, 0x10, 0xe5, 0xa2, 0x06, 0xa0, 0x03, 0xa9, // 3280 + 0x00, 0x48, 0xb9, 0x67, 0x02, 0x28, 0x01, 0x4c, // 3288 + 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 3290 + 0x30, 0xd9, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0xca, // 3298 + 0x88, 0x10, 0xe4, 0xa2, 0x06, 0xa0, 0x03, 0xa9, // 32a0 + 0xff, 0x48, 0xb9, 0x67, 0x02, 0x28, 0x01, 0x4c, // 32a8 + 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 32b0 + 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, 0xca, 0xca, // 32b8 + 0x88, 0x10, 0xe4, 0xa0, 0x03, 0xa9, 0x00, 0x48, // 32c0 + 0xb9, 0x67, 0x02, 0x28, 0x11, 0x4c, 0x08, 0xd9, // 32c8 + 0x73, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xd9, // 32d0 + 0x77, 0x02, 0xd0, 0xfe, 0x88, 0x10, 0xe6, 0xa0, // 32d8 + 0x03, 0xa9, 0xff, 0x48, 0xb9, 0x67, 0x02, 0x28, // 32e0 + 0x11, 0x4c, 0x08, 0xd9, 0x73, 0x02, 0xd0, 0xfe, // 32e8 + 0x68, 0x49, 0x7d, 0xd9, 0x77, 0x02, 0xd0, 0xfe, // 32f0 + 0x88, 0x10, 0xe6, 0x58, 0xad, 0x00, 0x02, 0xc9, // 32f8 + 0x28, 0xd0, 0xfe, 0xa9, 0x29, 0x8d, 0x00, 0x02, // 3300 + 0xd8, 0xa2, 0x0e, 0xa0, 0xff, 0xa9, 0x00, 0x85, // 3308 + 0x0c, 0x85, 0x0d, 0x85, 0x0e, 0x8d, 0x03, 0x02, // 3310 + 0x85, 0x0f, 0x85, 0x10, 0xa9, 0xff, 0x85, 0x12, // 3318 + 0x8d, 0x04, 0x02, 0xa9, 0x02, 0x85, 0x11, 0x18, // 3320 + 0x20, 0xa2, 0x35, 0xe6, 0x0c, 0xe6, 0x0f, 0x08, // 3328 + 0x08, 0x68, 0x29, 0x82, 0x28, 0xd0, 0x02, 0xe6, // 3330 + 0x10, 0x05, 0x10, 0x85, 0x11, 0x38, 0x20, 0xa2, // 3338 + 0x35, 0xc6, 0x0c, 0xe6, 0x0d, 0xd0, 0xe0, 0xa9, // 3340 + 0x00, 0x85, 0x10, 0xee, 0x03, 0x02, 0xe6, 0x0e, // 3348 + 0x08, 0x68, 0x29, 0x82, 0x85, 0x11, 0xc6, 0x12, // 3350 + 0xce, 0x04, 0x02, 0xa5, 0x0e, 0x85, 0x0f, 0xd0, // 3358 + 0xc6, 0xad, 0x00, 0x02, 0xc9, 0x29, 0xd0, 0xfe, // 3360 + 0xa9, 0x2a, 0x8d, 0x00, 0x02, 0xf8, 0xa2, 0x0e, // 3368 + 0xa0, 0xff, 0xa9, 0x99, 0x85, 0x0d, 0x85, 0x0e, // 3370 + 0x8d, 0x03, 0x02, 0x85, 0x0f, 0xa9, 0x01, 0x85, // 3378 + 0x0c, 0x85, 0x10, 0xa9, 0x00, 0x85, 0x12, 0x8d, // 3380 + 0x04, 0x02, 0x38, 0x20, 0x6f, 0x34, 0xc6, 0x0c, // 3388 + 0xa5, 0x0f, 0xd0, 0x08, 0xc6, 0x10, 0xa9, 0x99, // 3390 + 0x85, 0x0f, 0xd0, 0x12, 0x29, 0x0f, 0xd0, 0x0c, // 3398 + 0xc6, 0x0f, 0xc6, 0x0f, 0xc6, 0x0f, 0xc6, 0x0f, // 33a0 + 0xc6, 0x0f, 0xc6, 0x0f, 0xc6, 0x0f, 0x18, 0x20, // 33a8 + 0x6f, 0x34, 0xe6, 0x0c, 0xa5, 0x0d, 0xf0, 0x15, // 33b0 + 0x29, 0x0f, 0xd0, 0x0c, 0xc6, 0x0d, 0xc6, 0x0d, // 33b8 + 0xc6, 0x0d, 0xc6, 0x0d, 0xc6, 0x0d, 0xc6, 0x0d, // 33c0 + 0xc6, 0x0d, 0x4c, 0x8a, 0x33, 0xa9, 0x99, 0x85, // 33c8 + 0x0d, 0xa5, 0x0e, 0xf0, 0x30, 0x29, 0x0f, 0xd0, // 33d0 + 0x18, 0xc6, 0x0e, 0xc6, 0x0e, 0xc6, 0x0e, 0xc6, // 33d8 + 0x0e, 0xc6, 0x0e, 0xc6, 0x0e, 0xe6, 0x12, 0xe6, // 33e0 + 0x12, 0xe6, 0x12, 0xe6, 0x12, 0xe6, 0x12, 0xe6, // 33e8 + 0x12, 0xc6, 0x0e, 0xe6, 0x12, 0xa5, 0x12, 0x8d, // 33f0 + 0x04, 0x02, 0xa5, 0x0e, 0x8d, 0x03, 0x02, 0x85, // 33f8 + 0x0f, 0xe6, 0x10, 0xd0, 0x85, 0xad, 0x00, 0x02, // 3400 + 0xc9, 0x2a, 0xd0, 0xfe, 0xa9, 0x2b, 0x8d, 0x00, // 3408 + 0x02, 0x18, 0xd8, 0x08, 0xa9, 0x55, 0x69, 0x55, // 3410 + 0xc9, 0xaa, 0xd0, 0xfe, 0x18, 0xf8, 0x08, 0xa9, // 3418 + 0x55, 0x69, 0x55, 0xc9, 0x10, 0xd0, 0xfe, 0xd8, // 3420 + 0x28, 0xa9, 0x55, 0x69, 0x55, 0xc9, 0x10, 0xd0, // 3428 + 0xfe, 0x28, 0xa9, 0x55, 0x69, 0x55, 0xc9, 0xaa, // 3430 + 0xd0, 0xfe, 0x18, 0xa9, 0x34, 0x48, 0xa9, 0x55, // 3438 + 0x48, 0x08, 0xf8, 0xa9, 0x34, 0x48, 0xa9, 0x4c, // 3440 + 0x48, 0x08, 0xd8, 0x40, 0xa9, 0x55, 0x69, 0x55, // 3448 + 0xc9, 0x10, 0xd0, 0xfe, 0x40, 0xa9, 0x55, 0x69, // 3450 + 0x55, 0xc9, 0xaa, 0xd0, 0xfe, 0xad, 0x00, 0x02, // 3458 + 0xc9, 0x2b, 0xd0, 0xfe, 0xa9, 0xf0, 0x8d, 0x00, // 3460 + 0x02, 0x4c, 0x69, 0x34, 0x4c, 0x00, 0x04, 0x08, // 3468 + 0xa5, 0x0d, 0x65, 0x0e, 0x08, 0xc5, 0x0f, 0xd0, // 3470 + 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, 0xd0, 0xfe, // 3478 + 0x28, 0x08, 0xa5, 0x0d, 0xe5, 0x12, 0x08, 0xc5, // 3480 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, // 3488 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0x6d, 0x03, // 3490 + 0x02, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, // 3498 + 0x01, 0xc5, 0x10, 0xd0, 0xfe, 0x28, 0x08, 0xa5, // 34a0 + 0x0d, 0xed, 0x04, 0x02, 0x08, 0xc5, 0x0f, 0xd0, // 34a8 + 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, 0xd0, 0xfe, // 34b0 + 0x28, 0x08, 0xa5, 0x0e, 0x8d, 0x13, 0x02, 0xa5, // 34b8 + 0x0d, 0x20, 0x12, 0x02, 0x08, 0xc5, 0x0f, 0xd0, // 34c0 + 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, 0xd0, 0xfe, // 34c8 + 0x28, 0x08, 0xa5, 0x12, 0x8d, 0x16, 0x02, 0xa5, // 34d0 + 0x0d, 0x20, 0x15, 0x02, 0x08, 0xc5, 0x0f, 0xd0, // 34d8 + 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, 0xd0, 0xfe, // 34e0 + 0x28, 0x08, 0xa5, 0x0d, 0x75, 0x00, 0x08, 0xc5, // 34e8 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, // 34f0 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0xf5, 0x04, // 34f8 + 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x01, // 3500 + 0xc5, 0x10, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, // 3508 + 0x7d, 0xf5, 0x01, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, // 3510 + 0x68, 0x29, 0x01, 0xc5, 0x10, 0xd0, 0xfe, 0x28, // 3518 + 0x08, 0xa5, 0x0d, 0xfd, 0xf6, 0x01, 0x08, 0xc5, // 3520 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, // 3528 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0x79, 0x04, // 3530 + 0x01, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, // 3538 + 0x01, 0xc5, 0x10, 0xd0, 0xfe, 0x28, 0x08, 0xa5, // 3540 + 0x0d, 0xf9, 0x05, 0x01, 0x08, 0xc5, 0x0f, 0xd0, // 3548 + 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, 0xd0, 0xfe, // 3550 + 0x28, 0x08, 0xa5, 0x0d, 0x61, 0x46, 0x08, 0xc5, // 3558 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, // 3560 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0xe1, 0x48, // 3568 + 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x01, // 3570 + 0xc5, 0x10, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, // 3578 + 0x71, 0x58, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, // 3580 + 0x29, 0x01, 0xc5, 0x10, 0xd0, 0xfe, 0x28, 0x08, // 3588 + 0xa5, 0x0d, 0xf1, 0x5a, 0x08, 0xc5, 0x0f, 0xd0, // 3590 + 0xfe, 0x68, 0x29, 0x01, 0xc5, 0x10, 0xd0, 0xfe, // 3598 + 0x28, 0x60, 0xa5, 0x11, 0x29, 0x83, 0x48, 0xa5, // 35a0 + 0x0d, 0x45, 0x0e, 0x30, 0x0a, 0xa5, 0x0d, 0x45, // 35a8 + 0x0f, 0x10, 0x04, 0x68, 0x09, 0x40, 0x48, 0x68, // 35b0 + 0x85, 0x11, 0x08, 0xa5, 0x0d, 0x65, 0x0e, 0x08, // 35b8 + 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, // 35c0 + 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0xe5, // 35c8 + 0x12, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, // 35d0 + 0xc3, 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, // 35d8 + 0x0d, 0x6d, 0x03, 0x02, 0x08, 0xc5, 0x0f, 0xd0, // 35e0 + 0xfe, 0x68, 0x29, 0xc3, 0xc5, 0x11, 0xd0, 0xfe, // 35e8 + 0x28, 0x08, 0xa5, 0x0d, 0xed, 0x04, 0x02, 0x08, // 35f0 + 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, // 35f8 + 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0e, 0x8d, // 3600 + 0x13, 0x02, 0xa5, 0x0d, 0x20, 0x12, 0x02, 0x08, // 3608 + 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, // 3610 + 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x12, 0x8d, // 3618 + 0x16, 0x02, 0xa5, 0x0d, 0x20, 0x15, 0x02, 0x08, // 3620 + 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, // 3628 + 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0x75, // 3630 + 0x00, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, // 3638 + 0xc3, 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, // 3640 + 0x0d, 0xf5, 0x04, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, // 3648 + 0x68, 0x29, 0xc3, 0xc5, 0x11, 0xd0, 0xfe, 0x28, // 3650 + 0x08, 0xa5, 0x0d, 0x7d, 0xf5, 0x01, 0x08, 0xc5, // 3658 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, 0x11, // 3660 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0xfd, 0xf6, // 3668 + 0x01, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, // 3670 + 0xc3, 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, // 3678 + 0x0d, 0x79, 0x04, 0x01, 0x08, 0xc5, 0x0f, 0xd0, // 3680 + 0xfe, 0x68, 0x29, 0xc3, 0xc5, 0x11, 0xd0, 0xfe, // 3688 + 0x28, 0x08, 0xa5, 0x0d, 0xf9, 0x05, 0x01, 0x08, // 3690 + 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, // 3698 + 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0x61, // 36a0 + 0x46, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, // 36a8 + 0xc3, 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, // 36b0 + 0x0d, 0xe1, 0x48, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, // 36b8 + 0x68, 0x29, 0xc3, 0xc5, 0x11, 0xd0, 0xfe, 0x28, // 36c0 + 0x08, 0xa5, 0x0d, 0x71, 0x58, 0x08, 0xc5, 0x0f, // 36c8 + 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, 0x11, 0xd0, // 36d0 + 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0xf1, 0x5a, 0x08, // 36d8 + 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, // 36e0 + 0x11, 0xd0, 0xfe, 0x28, 0x60, 0x88, 0x88, 0x08, // 36e8 + 0x88, 0x88, 0x88, 0x28, 0xb0, 0xfe, 0x70, 0xfe, // 36f0 + 0x30, 0xfe, 0xf0, 0xfe, 0xc9, 0x46, 0xd0, 0xfe, // 36f8 + 0xe0, 0x41, 0xd0, 0xfe, 0xc0, 0x4f, 0xd0, 0xfe, // 3700 + 0x48, 0x8a, 0x48, 0xba, 0xe0, 0xfd, 0xd0, 0xfe, // 3708 + 0x68, 0xaa, 0xa9, 0xff, 0x48, 0x28, 0x68, 0xe8, // 3710 + 0x49, 0xaa, 0x4c, 0x0f, 0x09, 0x00, 0x27, 0x37, // 3718 + 0x64, 0x09, 0x4c, 0x22, 0x37, 0x88, 0x88, 0x08, // 3720 + 0x88, 0x88, 0x88, 0x28, 0xb0, 0xfe, 0x70, 0xfe, // 3728 + 0x30, 0xfe, 0xf0, 0xfe, 0xc9, 0x49, 0xd0, 0xfe, // 3730 + 0xe0, 0x4e, 0xd0, 0xfe, 0xc0, 0x41, 0xd0, 0xfe, // 3738 + 0x48, 0x8a, 0x48, 0xba, 0xe0, 0xfd, 0xd0, 0xfe, // 3740 + 0x68, 0xaa, 0xa9, 0xff, 0x48, 0x28, 0x68, 0xe8, // 3748 + 0x49, 0xaa, 0x6c, 0x20, 0x37, 0x4c, 0x55, 0x37, // 3750 + 0x4c, 0x00, 0x04, 0x88, 0x88, 0x08, 0x88, 0x88, // 3758 + 0x88, 0x28, 0xb0, 0xfe, 0x70, 0xfe, 0x30, 0xfe, // 3760 + 0xf0, 0xfe, 0xc9, 0x4a, 0xd0, 0xfe, 0xe0, 0x53, // 3768 + 0xd0, 0xfe, 0xc0, 0x4f, 0xd0, 0xfe, 0x48, 0x8a, // 3770 + 0x48, 0xba, 0xe0, 0xfb, 0xd0, 0xfe, 0xad, 0xff, // 3778 + 0x01, 0xc9, 0x09, 0xd0, 0xfe, 0xad, 0xfe, 0x01, // 3780 + 0xc9, 0x9a, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, // 3788 + 0x68, 0xaa, 0x68, 0xe8, 0x49, 0xaa, 0x60, 0x4c, // 3790 + 0x97, 0x37, 0x4c, 0x00, 0x04, 0x4c, 0x9d, 0x37, // 3798 + 0x4c, 0x00, 0x04, 0x4c, 0xa3, 0x37, 0x4c, 0x00, // 37a0 + 0x04, 0x88, 0x88, 0x08, 0x88, 0x88, 0x88, 0xc9, // 37a8 + 0xbd, 0xf0, 0x42, 0xc9, 0x42, 0xd0, 0xfe, 0xe0, // 37b0 + 0x52, 0xd0, 0xfe, 0xc0, 0x48, 0xd0, 0xfe, 0x85, // 37b8 + 0x0a, 0x86, 0x0b, 0xba, 0xbd, 0x02, 0x01, 0xc9, // 37c0 + 0x30, 0xd0, 0xfe, 0x68, 0xc9, 0x34, 0xd0, 0xfe, // 37c8 + 0xba, 0xe0, 0xfc, 0xd0, 0xfe, 0xad, 0xff, 0x01, // 37d0 + 0xc9, 0x09, 0xd0, 0xfe, 0xad, 0xfe, 0x01, 0xc9, // 37d8 + 0xd1, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0xa6, 0x0b, // 37e0 + 0xe8, 0xa5, 0x0a, 0x49, 0xaa, 0x28, 0x40, 0x4c, // 37e8 + 0xef, 0x37, 0x4c, 0x00, 0x04, 0xe0, 0xad, 0xd0, // 37f0 + 0xfe, 0xc0, 0xb1, 0xd0, 0xfe, 0x85, 0x0a, 0x86, // 37f8 + 0x0b, 0xba, 0xbd, 0x02, 0x01, 0xc9, 0xff, 0xd0, // 3800 + 0xfe, 0x68, 0x09, 0x08, 0xc9, 0xff, 0xd0, 0xfe, // 3808 + 0xba, 0xe0, 0xfc, 0xd0, 0xfe, 0xad, 0xff, 0x01, // 3810 + 0xc9, 0x09, 0xd0, 0xfe, 0xad, 0xfe, 0x01, 0xc9, // 3818 + 0xf7, 0xd0, 0xfe, 0xa9, 0x04, 0x48, 0xa6, 0x0b, // 3820 + 0xe8, 0xa5, 0x0a, 0x49, 0xaa, 0x28, 0x40, 0x4c, // 3828 + 0x2f, 0x38, 0x4c, 0x00, 0x04, 0xff, 0xff, 0xff, // 3830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aaa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aaa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aaf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aaf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ace0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ace8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ada0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ada8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // add0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // add8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ade0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ade8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aeb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aeb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // baa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // baa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // baf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // baf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bde0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bde8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // beb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // beb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // caa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // caa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // caf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // caf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cde0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cde8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ceb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ceb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ced0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ced8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // daa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // daa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // daf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // daf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dde0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dde8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // deb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // deb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ded0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ded8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // def0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // def8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eaa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eaa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ead0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ead8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eaf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eaf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ece0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ece8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ede0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ede8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eeb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eeb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // faa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // faa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // faf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // faf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fde0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fde8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // feb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // feb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fff0 + 0xff, 0xff, 0x9d, 0x37, 0xa3, 0x37, 0xab, 0x37, // fff8 +]; + +export default function Test6502ROM() { + let mem = [...MEMORY]; + return { + start: function() { + return 0x00; + }, + end: function() { + return 0xff; + }, + read: function(page, off) { + return mem[(page - 0x00) << 8 | off]; + }, + write: function(page, off, val) { + mem[(page - 0x00) << 8 | off] = val; + }, + reset: function() { + mem = [...MEMORY]; + }, + }; +} diff --git a/test/perf/test65c02rom.js b/test/perf/test65c02rom.js new file mode 100644 index 00000000..c46dde1b --- /dev/null +++ b/test/perf/test65c02rom.js @@ -0,0 +1,8215 @@ +const MEMORY = [ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0000 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0008 + 0x00, 0x00, 0x00, 0xc3, 0x82, 0x41, 0x00, 0x7f, // 0010 + 0x00, 0x1f, 0x71, 0x80, 0x0f, 0xff, 0x7f, 0x80, // 0018 + 0xff, 0x0f, 0x8f, 0x8f, 0x10, 0x02, 0x11, 0x02, // 0020 + 0x12, 0x02, 0x13, 0x02, 0x14, 0x02, 0x18, 0x01, // 0028 + 0x05, 0x02, 0x06, 0x02, 0x07, 0x02, 0x08, 0x02, // 0030 + 0x0d, 0x01, 0x47, 0x02, 0x48, 0x02, 0x49, 0x02, // 0038 + 0x4a, 0x02, 0x4b, 0x02, 0x4c, 0x02, 0x4d, 0x02, // 0040 + 0x4e, 0x02, 0x43, 0x02, 0x44, 0x02, 0x45, 0x02, // 0048 + 0x46, 0x02, 0x05, 0x02, 0x06, 0x02, 0x06, 0x01, // 0050 + 0x07, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 00f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 01f8 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0200 + 0x00, 0x00, 0x69, 0x00, 0x60, 0xe9, 0x00, 0x60, // 0208 + 0xc3, 0x82, 0x41, 0x00, 0x7f, 0x80, 0x80, 0x00, // 0210 + 0x02, 0x86, 0x04, 0x82, 0x00, 0x87, 0x05, 0x83, // 0218 + 0x01, 0x61, 0x41, 0x20, 0x00, 0xe1, 0xc1, 0xa0, // 0220 + 0x80, 0x81, 0x01, 0x80, 0x02, 0x81, 0x01, 0x80, // 0228 + 0x00, 0x01, 0x00, 0x01, 0x02, 0x81, 0x80, 0x81, // 0230 + 0x80, 0x7f, 0x80, 0xff, 0x00, 0x01, 0x00, 0x80, // 0238 + 0x80, 0x02, 0x00, 0x00, 0x1f, 0x71, 0x80, 0x0f, // 0240 + 0xff, 0x7f, 0x80, 0xff, 0x0f, 0x8f, 0x8f, 0x00, // 0248 + 0xf1, 0x1f, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, // 0250 + 0xf0, 0xf0, 0x0f, 0x00, 0xff, 0x7f, 0x80, 0x02, // 0258 + 0x80, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, // 0260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 02f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 0398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 03f8 + 0xd8, 0xa2, 0xff, 0x9a, 0xa9, 0x00, 0x8d, 0x02, // 0400 + 0x02, 0xad, 0x02, 0x02, 0xc9, 0x00, 0xd0, 0xfe, // 0408 + 0xa9, 0x01, 0x8d, 0x02, 0x02, 0xa9, 0x99, 0xa2, // 0410 + 0xff, 0x9a, 0xa2, 0x55, 0xda, 0xa2, 0xaa, 0xda, // 0418 + 0xec, 0xfe, 0x01, 0xd0, 0xfe, 0xba, 0xe0, 0xfd, // 0420 + 0xd0, 0xfe, 0x7a, 0xc0, 0xaa, 0xd0, 0xfe, 0x7a, // 0428 + 0xc0, 0x55, 0xd0, 0xfe, 0xcc, 0xff, 0x01, 0xd0, // 0430 + 0xfe, 0xba, 0xe0, 0xff, 0xd0, 0xfe, 0xa0, 0xa5, // 0438 + 0x5a, 0xa0, 0x5a, 0x5a, 0xcc, 0xfe, 0x01, 0xd0, // 0440 + 0xfe, 0xba, 0xe0, 0xfd, 0xd0, 0xfe, 0xfa, 0xe0, // 0448 + 0x5a, 0xd0, 0xfe, 0xfa, 0xe0, 0xa5, 0xd0, 0xfe, // 0450 + 0xec, 0xff, 0x01, 0xd0, 0xfe, 0xba, 0xe0, 0xff, // 0458 + 0xd0, 0xfe, 0xc9, 0x99, 0xd0, 0xfe, 0xad, 0x02, // 0460 + 0x02, 0xc9, 0x01, 0xd0, 0xfe, 0xa9, 0x02, 0x8d, // 0468 + 0x02, 0x02, 0xa0, 0xaa, 0xa9, 0xff, 0x48, 0xa2, // 0470 + 0x01, 0x28, 0xda, 0x08, 0xe0, 0x01, 0xd0, 0xfe, // 0478 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa9, // 0480 + 0x00, 0x48, 0xa2, 0x00, 0x28, 0xda, 0x08, 0xe0, // 0488 + 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, // 0490 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa2, 0xff, 0x28, // 0498 + 0xda, 0x08, 0xe0, 0xff, 0xd0, 0xfe, 0x68, 0x48, // 04a0 + 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, // 04a8 + 0xa2, 0x01, 0x28, 0xda, 0x08, 0xe0, 0x01, 0xd0, // 04b0 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 04b8 + 0xa9, 0xff, 0x48, 0xa2, 0x00, 0x28, 0xda, 0x08, // 04c0 + 0xe0, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 04c8 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa2, 0xff, // 04d0 + 0x28, 0xda, 0x08, 0xe0, 0xff, 0xd0, 0xfe, 0x68, // 04d8 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 04e0 + 0x48, 0xa2, 0x00, 0x28, 0xfa, 0x08, 0xe0, 0xff, // 04e8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, // 04f0 + 0x28, 0xa9, 0x00, 0x48, 0xa2, 0xff, 0x28, 0xfa, // 04f8 + 0x08, 0xe0, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0500 + 0x32, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa2, // 0508 + 0xfe, 0x28, 0xfa, 0x08, 0xe0, 0x01, 0xd0, 0xfe, // 0510 + 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, // 0518 + 0x00, 0x48, 0xa2, 0x00, 0x28, 0xfa, 0x08, 0xe0, // 0520 + 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, // 0528 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa2, 0xff, 0x28, // 0530 + 0xfa, 0x08, 0xe0, 0x00, 0xd0, 0xfe, 0x68, 0x48, // 0538 + 0xc9, 0x7f, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, // 0540 + 0xa2, 0xfe, 0x28, 0xfa, 0x08, 0xe0, 0x01, 0xd0, // 0548 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 0550 + 0xc0, 0xaa, 0xd0, 0xfe, 0xad, 0x02, 0x02, 0xc9, // 0558 + 0x02, 0xd0, 0xfe, 0xa9, 0x03, 0x8d, 0x02, 0x02, // 0560 + 0xa2, 0x55, 0xa9, 0xff, 0x48, 0xa0, 0x01, 0x28, // 0568 + 0x5a, 0x08, 0xc0, 0x01, 0xd0, 0xfe, 0x68, 0x48, // 0570 + 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, // 0578 + 0xa0, 0x00, 0x28, 0x5a, 0x08, 0xc0, 0x00, 0xd0, // 0580 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 0588 + 0xa9, 0xff, 0x48, 0xa0, 0xff, 0x28, 0x5a, 0x08, // 0590 + 0xc0, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 0598 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa0, 0x01, // 05a0 + 0x28, 0x5a, 0x08, 0xc0, 0x01, 0xd0, 0xfe, 0x68, // 05a8 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 05b0 + 0x48, 0xa0, 0x00, 0x28, 0x5a, 0x08, 0xc0, 0x00, // 05b8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, // 05c0 + 0x28, 0xa9, 0x00, 0x48, 0xa0, 0xff, 0x28, 0x5a, // 05c8 + 0x08, 0xc0, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 05d0 + 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa0, // 05d8 + 0x00, 0x28, 0x7a, 0x08, 0xc0, 0xff, 0xd0, 0xfe, // 05e0 + 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, 0x28, 0xa9, // 05e8 + 0x00, 0x48, 0xa0, 0xff, 0x28, 0x7a, 0x08, 0xc0, // 05f0 + 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x32, 0xd0, // 05f8 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa0, 0xfe, 0x28, // 0600 + 0x7a, 0x08, 0xc0, 0x01, 0xd0, 0xfe, 0x68, 0x48, // 0608 + 0xc9, 0x7d, 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, // 0610 + 0xa0, 0x00, 0x28, 0x7a, 0x08, 0xc0, 0xff, 0xd0, // 0618 + 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, 0xfe, 0x28, // 0620 + 0xa9, 0xff, 0x48, 0xa0, 0xff, 0x28, 0x7a, 0x08, // 0628 + 0xc0, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, // 0630 + 0xd0, 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa0, 0xfe, // 0638 + 0x28, 0x7a, 0x08, 0xc0, 0x01, 0xd0, 0xfe, 0x68, // 0640 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xe0, 0x55, // 0648 + 0xd0, 0xfe, 0xad, 0x02, 0x02, 0xc9, 0x03, 0xd0, // 0650 + 0xfe, 0xa9, 0x04, 0x8d, 0x02, 0x02, 0xa2, 0x81, // 0658 + 0xa0, 0x7e, 0xa9, 0xff, 0x48, 0xa9, 0x00, 0x28, // 0660 + 0x80, 0x03, 0x4c, 0x6a, 0x06, 0x08, 0xc9, 0x00, // 0668 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, // 0670 + 0x28, 0xa9, 0x00, 0x48, 0xa9, 0xff, 0x28, 0x80, // 0678 + 0x03, 0x4c, 0x81, 0x06, 0x08, 0xc9, 0xff, 0xd0, // 0680 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 0688 + 0xe0, 0x81, 0xd0, 0xfe, 0xc0, 0x7e, 0xd0, 0xfe, // 0690 + 0xad, 0x02, 0x02, 0xc9, 0x04, 0xd0, 0xfe, 0xa9, // 0698 + 0x05, 0x8d, 0x02, 0x02, 0xa0, 0x00, 0x80, 0x61, // 06a0 + 0xc0, 0x01, 0xd0, 0xfe, 0xc8, 0x80, 0x53, 0xc0, // 06a8 + 0x03, 0xd0, 0xfe, 0xc8, 0x80, 0x45, 0xc0, 0x05, // 06b0 + 0xd0, 0xfe, 0xc8, 0xa0, 0x00, 0x80, 0x04, 0xc8, // 06b8 + 0xc8, 0xc8, 0xc8, 0x80, 0x03, 0xc8, 0xc8, 0xc8, // 06c0 + 0xc8, 0x80, 0x02, 0xc8, 0xc8, 0xc8, 0xc8, 0x80, // 06c8 + 0x01, 0xc8, 0xc8, 0xc8, 0xc8, 0x80, 0x00, 0xc8, // 06d0 + 0xc8, 0xc8, 0xc8, 0xc0, 0x0a, 0xd0, 0xfe, 0x80, // 06d8 + 0x12, 0x88, 0x88, 0x88, 0x88, 0x80, 0x0e, 0x88, // 06e0 + 0x88, 0x88, 0x80, 0xf5, 0x88, 0x88, 0x80, 0xf7, // 06e8 + 0x88, 0x80, 0xf9, 0x80, 0xfb, 0xc0, 0x00, 0xd0, // 06f0 + 0xfe, 0x80, 0x15, 0xc0, 0x04, 0xd0, 0xfe, 0xc8, // 06f8 + 0x80, 0xb4, 0xc0, 0x02, 0xd0, 0xfe, 0xc8, 0x80, // 0700 + 0xa6, 0xc0, 0x00, 0xd0, 0xfe, 0xc8, 0x80, 0x98, // 0708 + 0xad, 0x02, 0x02, 0xc9, 0x05, 0xd0, 0xfe, 0xa9, // 0710 + 0x06, 0x8d, 0x02, 0x02, 0xa2, 0x11, 0xa0, 0x22, // 0718 + 0xa9, 0x01, 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, // 0720 + 0x33, 0x28, 0x0f, 0x0c, 0x06, 0x8f, 0x0c, 0x06, // 0728 + 0x4c, 0x30, 0x07, 0x4c, 0x33, 0x07, 0x08, 0xc9, // 0730 + 0x33, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, // 0738 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xcc, 0x28, // 0740 + 0x0f, 0x0c, 0x06, 0x8f, 0x0c, 0x06, 0x4c, 0x4e, // 0748 + 0x07, 0x4c, 0x51, 0x07, 0x08, 0xc9, 0xcc, 0xd0, // 0750 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0758 + 0xa5, 0x0c, 0xc9, 0x01, 0xd0, 0xfe, 0xa9, 0xfe, // 0760 + 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0x33, 0x28, // 0768 + 0x8f, 0x0c, 0x06, 0x0f, 0x0c, 0x06, 0x4c, 0x76, // 0770 + 0x07, 0x4c, 0x79, 0x07, 0x08, 0xc9, 0x33, 0xd0, // 0778 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 0780 + 0xa9, 0xff, 0x48, 0xa9, 0xcc, 0x28, 0x8f, 0x0c, // 0788 + 0x06, 0x0f, 0x0c, 0x06, 0x4c, 0x94, 0x07, 0x4c, // 0790 + 0x97, 0x07, 0x08, 0xc9, 0xcc, 0xd0, 0xfe, 0x68, // 0798 + 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, // 07a0 + 0xc9, 0xfe, 0xd0, 0xfe, 0xa9, 0x02, 0x85, 0x0c, // 07a8 + 0xa9, 0x00, 0x48, 0xa9, 0x33, 0x28, 0x1f, 0x0c, // 07b0 + 0x06, 0x9f, 0x0c, 0x06, 0x4c, 0xbc, 0x07, 0x4c, // 07b8 + 0xbf, 0x07, 0x08, 0xc9, 0x33, 0xd0, 0xfe, 0x68, // 07c0 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 07c8 + 0x48, 0xa9, 0xcc, 0x28, 0x1f, 0x0c, 0x06, 0x9f, // 07d0 + 0x0c, 0x06, 0x4c, 0xda, 0x07, 0x4c, 0xdd, 0x07, // 07d8 + 0x08, 0xc9, 0xcc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 07e0 + 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x02, // 07e8 + 0xd0, 0xfe, 0xa9, 0xfd, 0x85, 0x0c, 0xa9, 0x00, // 07f0 + 0x48, 0xa9, 0x33, 0x28, 0x9f, 0x0c, 0x06, 0x1f, // 07f8 + 0x0c, 0x06, 0x4c, 0x02, 0x08, 0x4c, 0x05, 0x08, // 0800 + 0x08, 0xc9, 0x33, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0808 + 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, // 0810 + 0xcc, 0x28, 0x9f, 0x0c, 0x06, 0x1f, 0x0c, 0x06, // 0818 + 0x4c, 0x20, 0x08, 0x4c, 0x23, 0x08, 0x08, 0xc9, // 0820 + 0xcc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, // 0828 + 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0xfd, 0xd0, 0xfe, // 0830 + 0xa9, 0x04, 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, // 0838 + 0x33, 0x28, 0x2f, 0x0c, 0x06, 0xaf, 0x0c, 0x06, // 0840 + 0x4c, 0x48, 0x08, 0x4c, 0x4b, 0x08, 0x08, 0xc9, // 0848 + 0x33, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, // 0850 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xcc, 0x28, // 0858 + 0x2f, 0x0c, 0x06, 0xaf, 0x0c, 0x06, 0x4c, 0x66, // 0860 + 0x08, 0x4c, 0x69, 0x08, 0x08, 0xc9, 0xcc, 0xd0, // 0868 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0870 + 0xa5, 0x0c, 0xc9, 0x04, 0xd0, 0xfe, 0xa9, 0xfb, // 0878 + 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0x33, 0x28, // 0880 + 0xaf, 0x0c, 0x06, 0x2f, 0x0c, 0x06, 0x4c, 0x8e, // 0888 + 0x08, 0x4c, 0x91, 0x08, 0x08, 0xc9, 0x33, 0xd0, // 0890 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 0898 + 0xa9, 0xff, 0x48, 0xa9, 0xcc, 0x28, 0xaf, 0x0c, // 08a0 + 0x06, 0x2f, 0x0c, 0x06, 0x4c, 0xac, 0x08, 0x4c, // 08a8 + 0xaf, 0x08, 0x08, 0xc9, 0xcc, 0xd0, 0xfe, 0x68, // 08b0 + 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, // 08b8 + 0xc9, 0xfb, 0xd0, 0xfe, 0xa9, 0x08, 0x85, 0x0c, // 08c0 + 0xa9, 0x00, 0x48, 0xa9, 0x33, 0x28, 0x3f, 0x0c, // 08c8 + 0x06, 0xbf, 0x0c, 0x06, 0x4c, 0xd4, 0x08, 0x4c, // 08d0 + 0xd7, 0x08, 0x08, 0xc9, 0x33, 0xd0, 0xfe, 0x68, // 08d8 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 08e0 + 0x48, 0xa9, 0xcc, 0x28, 0x3f, 0x0c, 0x06, 0xbf, // 08e8 + 0x0c, 0x06, 0x4c, 0xf2, 0x08, 0x4c, 0xf5, 0x08, // 08f0 + 0x08, 0xc9, 0xcc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 08f8 + 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x08, // 0900 + 0xd0, 0xfe, 0xa9, 0xf7, 0x85, 0x0c, 0xa9, 0x00, // 0908 + 0x48, 0xa9, 0x33, 0x28, 0xbf, 0x0c, 0x06, 0x3f, // 0910 + 0x0c, 0x06, 0x4c, 0x1a, 0x09, 0x4c, 0x1d, 0x09, // 0918 + 0x08, 0xc9, 0x33, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0920 + 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, // 0928 + 0xcc, 0x28, 0xbf, 0x0c, 0x06, 0x3f, 0x0c, 0x06, // 0930 + 0x4c, 0x38, 0x09, 0x4c, 0x3b, 0x09, 0x08, 0xc9, // 0938 + 0xcc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, // 0940 + 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0xf7, 0xd0, 0xfe, // 0948 + 0xa9, 0x10, 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, // 0950 + 0x33, 0x28, 0x4f, 0x0c, 0x06, 0xcf, 0x0c, 0x06, // 0958 + 0x4c, 0x60, 0x09, 0x4c, 0x63, 0x09, 0x08, 0xc9, // 0960 + 0x33, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, // 0968 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xcc, 0x28, // 0970 + 0x4f, 0x0c, 0x06, 0xcf, 0x0c, 0x06, 0x4c, 0x7e, // 0978 + 0x09, 0x4c, 0x81, 0x09, 0x08, 0xc9, 0xcc, 0xd0, // 0980 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0988 + 0xa5, 0x0c, 0xc9, 0x10, 0xd0, 0xfe, 0xa9, 0xef, // 0990 + 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0x33, 0x28, // 0998 + 0xcf, 0x0c, 0x06, 0x4f, 0x0c, 0x06, 0x4c, 0xa6, // 09a0 + 0x09, 0x4c, 0xa9, 0x09, 0x08, 0xc9, 0x33, 0xd0, // 09a8 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 09b0 + 0xa9, 0xff, 0x48, 0xa9, 0xcc, 0x28, 0xcf, 0x0c, // 09b8 + 0x06, 0x4f, 0x0c, 0x06, 0x4c, 0xc4, 0x09, 0x4c, // 09c0 + 0xc7, 0x09, 0x08, 0xc9, 0xcc, 0xd0, 0xfe, 0x68, // 09c8 + 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, // 09d0 + 0xc9, 0xef, 0xd0, 0xfe, 0xa9, 0x20, 0x85, 0x0c, // 09d8 + 0xa9, 0x00, 0x48, 0xa9, 0x33, 0x28, 0x5f, 0x0c, // 09e0 + 0x06, 0xdf, 0x0c, 0x06, 0x4c, 0xec, 0x09, 0x4c, // 09e8 + 0xef, 0x09, 0x08, 0xc9, 0x33, 0xd0, 0xfe, 0x68, // 09f0 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 09f8 + 0x48, 0xa9, 0xcc, 0x28, 0x5f, 0x0c, 0x06, 0xdf, // 0a00 + 0x0c, 0x06, 0x4c, 0x0a, 0x0a, 0x4c, 0x0d, 0x0a, // 0a08 + 0x08, 0xc9, 0xcc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0a10 + 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x20, // 0a18 + 0xd0, 0xfe, 0xa9, 0xdf, 0x85, 0x0c, 0xa9, 0x00, // 0a20 + 0x48, 0xa9, 0x33, 0x28, 0xdf, 0x0c, 0x06, 0x5f, // 0a28 + 0x0c, 0x06, 0x4c, 0x32, 0x0a, 0x4c, 0x35, 0x0a, // 0a30 + 0x08, 0xc9, 0x33, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0a38 + 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, // 0a40 + 0xcc, 0x28, 0xdf, 0x0c, 0x06, 0x5f, 0x0c, 0x06, // 0a48 + 0x4c, 0x50, 0x0a, 0x4c, 0x53, 0x0a, 0x08, 0xc9, // 0a50 + 0xcc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, // 0a58 + 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0xdf, 0xd0, 0xfe, // 0a60 + 0xa9, 0x40, 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, // 0a68 + 0x33, 0x28, 0x6f, 0x0c, 0x06, 0xef, 0x0c, 0x06, // 0a70 + 0x4c, 0x78, 0x0a, 0x4c, 0x7b, 0x0a, 0x08, 0xc9, // 0a78 + 0x33, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, // 0a80 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xcc, 0x28, // 0a88 + 0x6f, 0x0c, 0x06, 0xef, 0x0c, 0x06, 0x4c, 0x96, // 0a90 + 0x0a, 0x4c, 0x99, 0x0a, 0x08, 0xc9, 0xcc, 0xd0, // 0a98 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0aa0 + 0xa5, 0x0c, 0xc9, 0x40, 0xd0, 0xfe, 0xa9, 0xbf, // 0aa8 + 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0x33, 0x28, // 0ab0 + 0xef, 0x0c, 0x06, 0x6f, 0x0c, 0x06, 0x4c, 0xbe, // 0ab8 + 0x0a, 0x4c, 0xc1, 0x0a, 0x08, 0xc9, 0x33, 0xd0, // 0ac0 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 0ac8 + 0xa9, 0xff, 0x48, 0xa9, 0xcc, 0x28, 0xef, 0x0c, // 0ad0 + 0x06, 0x6f, 0x0c, 0x06, 0x4c, 0xdc, 0x0a, 0x4c, // 0ad8 + 0xdf, 0x0a, 0x08, 0xc9, 0xcc, 0xd0, 0xfe, 0x68, // 0ae0 + 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, // 0ae8 + 0xc9, 0xbf, 0xd0, 0xfe, 0xa9, 0x80, 0x85, 0x0c, // 0af0 + 0xa9, 0x00, 0x48, 0xa9, 0x33, 0x28, 0x7f, 0x0c, // 0af8 + 0x06, 0xff, 0x0c, 0x06, 0x4c, 0x04, 0x0b, 0x4c, // 0b00 + 0x07, 0x0b, 0x08, 0xc9, 0x33, 0xd0, 0xfe, 0x68, // 0b08 + 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 0b10 + 0x48, 0xa9, 0xcc, 0x28, 0x7f, 0x0c, 0x06, 0xff, // 0b18 + 0x0c, 0x06, 0x4c, 0x22, 0x0b, 0x4c, 0x25, 0x0b, // 0b20 + 0x08, 0xc9, 0xcc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0b28 + 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x80, // 0b30 + 0xd0, 0xfe, 0xa9, 0x7f, 0x85, 0x0c, 0xa9, 0x00, // 0b38 + 0x48, 0xa9, 0x33, 0x28, 0xff, 0x0c, 0x06, 0x7f, // 0b40 + 0x0c, 0x06, 0x4c, 0x4a, 0x0b, 0x4c, 0x4d, 0x0b, // 0b48 + 0x08, 0xc9, 0x33, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0b50 + 0x30, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, // 0b58 + 0xcc, 0x28, 0xff, 0x0c, 0x06, 0x7f, 0x0c, 0x06, // 0b60 + 0x4c, 0x68, 0x0b, 0x4c, 0x6b, 0x0b, 0x08, 0xc9, // 0b68 + 0xcc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, // 0b70 + 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x7f, 0xd0, 0xfe, // 0b78 + 0xe0, 0x11, 0xd0, 0xfe, 0xc0, 0x22, 0xd0, 0xfe, // 0b80 + 0xad, 0x02, 0x02, 0xc9, 0x06, 0xd0, 0xfe, 0xa9, // 0b88 + 0x07, 0x8d, 0x02, 0x02, 0xa9, 0x00, 0x85, 0x0c, // 0b90 + 0xa9, 0x00, 0x0f, 0x0c, 0x02, 0x49, 0x01, 0x1f, // 0b98 + 0x0c, 0x02, 0x49, 0x02, 0x2f, 0x0c, 0x02, 0x49, // 0ba0 + 0x04, 0x3f, 0x0c, 0x02, 0x49, 0x08, 0x4f, 0x0c, // 0ba8 + 0x02, 0x49, 0x10, 0x5f, 0x0c, 0x02, 0x49, 0x20, // 0bb0 + 0x6f, 0x0c, 0x02, 0x49, 0x40, 0x7f, 0x0c, 0x02, // 0bb8 + 0x49, 0x80, 0x45, 0x0c, 0xd0, 0xfe, 0xa9, 0xff, // 0bc0 + 0x8f, 0x0c, 0x02, 0x49, 0x01, 0x9f, 0x0c, 0x02, // 0bc8 + 0x49, 0x02, 0xaf, 0x0c, 0x02, 0x49, 0x04, 0xbf, // 0bd0 + 0x0c, 0x02, 0x49, 0x08, 0xcf, 0x0c, 0x02, 0x49, // 0bd8 + 0x10, 0xdf, 0x0c, 0x02, 0x49, 0x20, 0xef, 0x0c, // 0be0 + 0x02, 0x49, 0x40, 0xff, 0x0c, 0x02, 0x49, 0x80, // 0be8 + 0x45, 0x0c, 0xd0, 0xfe, 0xe6, 0x0c, 0xd0, 0xa0, // 0bf0 + 0xad, 0x02, 0x02, 0xc9, 0x07, 0xd0, 0xfe, 0xa9, // 0bf8 + 0x08, 0x8d, 0x02, 0x02, 0xa0, 0x42, 0xa2, 0x02, // 0c00 + 0x02, 0xc8, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0c08 + 0x48, 0xa9, 0xfd, 0x28, 0x02, 0xea, 0xea, 0x08, // 0c10 + 0xc9, 0xfd, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0c18 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xa8, // 0c20 + 0x28, 0x02, 0xea, 0xea, 0x08, 0xc9, 0xa8, 0xd0, // 0c28 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0c30 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0c38 + 0xa0, 0x42, 0xa2, 0x02, 0x22, 0xc8, 0xca, 0xca, // 0c40 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xdd, 0x28, // 0c48 + 0x22, 0xea, 0xea, 0x08, 0xc9, 0xdd, 0xd0, 0xfe, // 0c50 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 0c58 + 0xff, 0x48, 0xa9, 0x88, 0x28, 0x22, 0xea, 0xea, // 0c60 + 0x08, 0xc9, 0x88, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0c68 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 0c70 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x02, // 0c78 + 0x42, 0xc8, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0c80 + 0x48, 0xa9, 0xbd, 0x28, 0x42, 0xea, 0xea, 0x08, // 0c88 + 0xc9, 0xbd, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0c90 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x68, // 0c98 + 0x28, 0x42, 0xea, 0xea, 0x08, 0xc9, 0x68, 0xd0, // 0ca0 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0ca8 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0cb0 + 0xa0, 0x42, 0xa2, 0x02, 0x62, 0xc8, 0xca, 0xca, // 0cb8 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x9d, 0x28, // 0cc0 + 0x62, 0xea, 0xea, 0x08, 0xc9, 0x9d, 0xd0, 0xfe, // 0cc8 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 0cd0 + 0xff, 0x48, 0xa9, 0x48, 0x28, 0x62, 0xea, 0xea, // 0cd8 + 0x08, 0xc9, 0x48, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0ce0 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 0ce8 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x02, // 0cf0 + 0x82, 0xc8, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0cf8 + 0x48, 0xa9, 0x7d, 0x28, 0x82, 0xea, 0xea, 0x08, // 0d00 + 0xc9, 0x7d, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0d08 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x28, // 0d10 + 0x28, 0x82, 0xea, 0xea, 0x08, 0xc9, 0x28, 0xd0, // 0d18 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0d20 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0d28 + 0xa0, 0x42, 0xa2, 0x02, 0xc2, 0xc8, 0xca, 0xca, // 0d30 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x3d, 0x28, // 0d38 + 0xc2, 0xea, 0xea, 0x08, 0xc9, 0x3d, 0xd0, 0xfe, // 0d40 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 0d48 + 0xff, 0x48, 0xa9, 0xe8, 0x28, 0xc2, 0xea, 0xea, // 0d50 + 0x08, 0xc9, 0xe8, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0d58 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 0d60 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x02, // 0d68 + 0xe2, 0xc8, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0d70 + 0x48, 0xa9, 0x1d, 0x28, 0xe2, 0xea, 0xea, 0x08, // 0d78 + 0xc9, 0x1d, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0d80 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xc8, // 0d88 + 0x28, 0xe2, 0xea, 0xea, 0x08, 0xc9, 0xc8, 0xd0, // 0d90 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0d98 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0da0 + 0xa0, 0x42, 0xa2, 0x02, 0x44, 0xc8, 0xca, 0xca, // 0da8 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xbb, 0x28, // 0db0 + 0x44, 0xea, 0xea, 0x08, 0xc9, 0xbb, 0xd0, 0xfe, // 0db8 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 0dc0 + 0xff, 0x48, 0xa9, 0x66, 0x28, 0x44, 0xea, 0xea, // 0dc8 + 0x08, 0xc9, 0x66, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0dd0 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 0dd8 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x02, // 0de0 + 0x54, 0xc8, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0de8 + 0x48, 0xa9, 0xab, 0x28, 0x54, 0xea, 0xea, 0x08, // 0df0 + 0xc9, 0xab, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0df8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x56, // 0e00 + 0x28, 0x54, 0xea, 0xea, 0x08, 0xc9, 0x56, 0xd0, // 0e08 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0e10 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0e18 + 0xa0, 0x42, 0xa2, 0x02, 0xd4, 0xc8, 0xca, 0xca, // 0e20 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x2b, 0x28, // 0e28 + 0xd4, 0xea, 0xea, 0x08, 0xc9, 0x2b, 0xd0, 0xfe, // 0e30 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 0e38 + 0xff, 0x48, 0xa9, 0xd6, 0x28, 0xd4, 0xea, 0xea, // 0e40 + 0x08, 0xc9, 0xd6, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0e48 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 0e50 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x02, // 0e58 + 0xf4, 0xc8, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0e60 + 0x48, 0xa9, 0x0b, 0x28, 0xf4, 0xea, 0xea, 0x08, // 0e68 + 0xc9, 0x0b, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0e70 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xb6, // 0e78 + 0x28, 0xf4, 0xea, 0xea, 0x08, 0xc9, 0xb6, 0xd0, // 0e80 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0e88 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0e90 + 0xa0, 0x42, 0xa2, 0x01, 0x5c, 0xc8, 0xc8, 0xca, // 0e98 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xa3, 0x28, // 0ea0 + 0x5c, 0xea, 0xea, 0x08, 0xc9, 0xa3, 0xd0, 0xfe, // 0ea8 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 0eb0 + 0xff, 0x48, 0xa9, 0x4e, 0x28, 0x5c, 0xea, 0xea, // 0eb8 + 0x08, 0xc9, 0x4e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0ec0 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 0ec8 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x01, // 0ed0 + 0xdc, 0xc8, 0xc8, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0ed8 + 0x48, 0xa9, 0x23, 0x28, 0xdc, 0xea, 0xea, 0x08, // 0ee0 + 0xc9, 0x23, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0ee8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xce, // 0ef0 + 0x28, 0xdc, 0xea, 0xea, 0x08, 0xc9, 0xce, 0xd0, // 0ef8 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0f00 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0f08 + 0xa0, 0x42, 0xa2, 0x01, 0xfc, 0xc8, 0xc8, 0xca, // 0f10 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x03, 0x28, // 0f18 + 0xfc, 0xea, 0xea, 0x08, 0xc9, 0x03, 0xd0, 0xfe, // 0f20 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 0f28 + 0xff, 0x48, 0xa9, 0xae, 0x28, 0xfc, 0xea, 0xea, // 0f30 + 0x08, 0xc9, 0xae, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0f38 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 0f40 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 0f48 + 0x03, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0f50 + 0x48, 0xa9, 0xfc, 0x28, 0x03, 0xea, 0xea, 0x08, // 0f58 + 0xc9, 0xfc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0f60 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xa7, // 0f68 + 0x28, 0x03, 0xea, 0xea, 0x08, 0xc9, 0xa7, 0xd0, // 0f70 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0f78 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0f80 + 0xa0, 0x42, 0xa2, 0x03, 0x13, 0xca, 0xca, 0xca, // 0f88 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xec, 0x28, // 0f90 + 0x13, 0xea, 0xea, 0x08, 0xc9, 0xec, 0xd0, 0xfe, // 0f98 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 0fa0 + 0xff, 0x48, 0xa9, 0x97, 0x28, 0x13, 0xea, 0xea, // 0fa8 + 0x08, 0xc9, 0x97, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 0fb0 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 0fb8 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 0fc0 + 0x23, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 0fc8 + 0x48, 0xa9, 0xdc, 0x28, 0x23, 0xea, 0xea, 0x08, // 0fd0 + 0xc9, 0xdc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 0fd8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x87, // 0fe0 + 0x28, 0x23, 0xea, 0xea, 0x08, 0xc9, 0x87, 0xd0, // 0fe8 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 0ff0 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 0ff8 + 0xa0, 0x42, 0xa2, 0x03, 0x33, 0xca, 0xca, 0xca, // 1000 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xcc, 0x28, // 1008 + 0x33, 0xea, 0xea, 0x08, 0xc9, 0xcc, 0xd0, 0xfe, // 1010 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1018 + 0xff, 0x48, 0xa9, 0x77, 0x28, 0x33, 0xea, 0xea, // 1020 + 0x08, 0xc9, 0x77, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1028 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1030 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 1038 + 0x43, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1040 + 0x48, 0xa9, 0xbc, 0x28, 0x43, 0xea, 0xea, 0x08, // 1048 + 0xc9, 0xbc, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1050 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x67, // 1058 + 0x28, 0x43, 0xea, 0xea, 0x08, 0xc9, 0x67, 0xd0, // 1060 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 1068 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 1070 + 0xa0, 0x42, 0xa2, 0x03, 0x53, 0xca, 0xca, 0xca, // 1078 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xac, 0x28, // 1080 + 0x53, 0xea, 0xea, 0x08, 0xc9, 0xac, 0xd0, 0xfe, // 1088 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1090 + 0xff, 0x48, 0xa9, 0x57, 0x28, 0x53, 0xea, 0xea, // 1098 + 0x08, 0xc9, 0x57, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 10a0 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 10a8 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 10b0 + 0x63, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 10b8 + 0x48, 0xa9, 0x9c, 0x28, 0x63, 0xea, 0xea, 0x08, // 10c0 + 0xc9, 0x9c, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 10c8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x47, // 10d0 + 0x28, 0x63, 0xea, 0xea, 0x08, 0xc9, 0x47, 0xd0, // 10d8 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 10e0 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 10e8 + 0xa0, 0x42, 0xa2, 0x03, 0x73, 0xca, 0xca, 0xca, // 10f0 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x8c, 0x28, // 10f8 + 0x73, 0xea, 0xea, 0x08, 0xc9, 0x8c, 0xd0, 0xfe, // 1100 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1108 + 0xff, 0x48, 0xa9, 0x37, 0x28, 0x73, 0xea, 0xea, // 1110 + 0x08, 0xc9, 0x37, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1118 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1120 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 1128 + 0x83, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1130 + 0x48, 0xa9, 0x7c, 0x28, 0x83, 0xea, 0xea, 0x08, // 1138 + 0xc9, 0x7c, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1140 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x27, // 1148 + 0x28, 0x83, 0xea, 0xea, 0x08, 0xc9, 0x27, 0xd0, // 1150 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 1158 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 1160 + 0xa0, 0x42, 0xa2, 0x03, 0x93, 0xca, 0xca, 0xca, // 1168 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x6c, 0x28, // 1170 + 0x93, 0xea, 0xea, 0x08, 0xc9, 0x6c, 0xd0, 0xfe, // 1178 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1180 + 0xff, 0x48, 0xa9, 0x17, 0x28, 0x93, 0xea, 0xea, // 1188 + 0x08, 0xc9, 0x17, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1190 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1198 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 11a0 + 0xa3, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 11a8 + 0x48, 0xa9, 0x5c, 0x28, 0xa3, 0xea, 0xea, 0x08, // 11b0 + 0xc9, 0x5c, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 11b8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x07, // 11c0 + 0x28, 0xa3, 0xea, 0xea, 0x08, 0xc9, 0x07, 0xd0, // 11c8 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 11d0 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 11d8 + 0xa0, 0x42, 0xa2, 0x03, 0xb3, 0xca, 0xca, 0xca, // 11e0 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x4c, 0x28, // 11e8 + 0xb3, 0xea, 0xea, 0x08, 0xc9, 0x4c, 0xd0, 0xfe, // 11f0 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 11f8 + 0xff, 0x48, 0xa9, 0xf7, 0x28, 0xb3, 0xea, 0xea, // 1200 + 0x08, 0xc9, 0xf7, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1208 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1210 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 1218 + 0xc3, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1220 + 0x48, 0xa9, 0x3c, 0x28, 0xc3, 0xea, 0xea, 0x08, // 1228 + 0xc9, 0x3c, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1230 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xe7, // 1238 + 0x28, 0xc3, 0xea, 0xea, 0x08, 0xc9, 0xe7, 0xd0, // 1240 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 1248 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 1250 + 0xa0, 0x42, 0xa2, 0x03, 0xd3, 0xca, 0xca, 0xca, // 1258 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x2c, 0x28, // 1260 + 0xd3, 0xea, 0xea, 0x08, 0xc9, 0x2c, 0xd0, 0xfe, // 1268 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1270 + 0xff, 0x48, 0xa9, 0xd7, 0x28, 0xd3, 0xea, 0xea, // 1278 + 0x08, 0xc9, 0xd7, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1280 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1288 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 1290 + 0xe3, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1298 + 0x48, 0xa9, 0x1c, 0x28, 0xe3, 0xea, 0xea, 0x08, // 12a0 + 0xc9, 0x1c, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 12a8 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xc7, // 12b0 + 0x28, 0xe3, 0xea, 0xea, 0x08, 0xc9, 0xc7, 0xd0, // 12b8 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 12c0 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 12c8 + 0xa0, 0x42, 0xa2, 0x03, 0xf3, 0xca, 0xca, 0xca, // 12d0 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x0c, 0x28, // 12d8 + 0xf3, 0xea, 0xea, 0x08, 0xc9, 0x0c, 0xd0, 0xfe, // 12e0 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 12e8 + 0xff, 0x48, 0xa9, 0xb7, 0x28, 0xf3, 0xea, 0xea, // 12f0 + 0x08, 0xc9, 0xb7, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 12f8 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1300 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 1308 + 0x0b, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1310 + 0x48, 0xa9, 0xf4, 0x28, 0x0b, 0xea, 0xea, 0x08, // 1318 + 0xc9, 0xf4, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1320 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x9f, // 1328 + 0x28, 0x0b, 0xea, 0xea, 0x08, 0xc9, 0x9f, 0xd0, // 1330 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 1338 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 1340 + 0xa0, 0x42, 0xa2, 0x03, 0x1b, 0xca, 0xca, 0xca, // 1348 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xe4, 0x28, // 1350 + 0x1b, 0xea, 0xea, 0x08, 0xc9, 0xe4, 0xd0, 0xfe, // 1358 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1360 + 0xff, 0x48, 0xa9, 0x8f, 0x28, 0x1b, 0xea, 0xea, // 1368 + 0x08, 0xc9, 0x8f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1370 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1378 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 1380 + 0x2b, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1388 + 0x48, 0xa9, 0xd4, 0x28, 0x2b, 0xea, 0xea, 0x08, // 1390 + 0xc9, 0xd4, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1398 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7f, // 13a0 + 0x28, 0x2b, 0xea, 0xea, 0x08, 0xc9, 0x7f, 0xd0, // 13a8 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 13b0 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 13b8 + 0xa0, 0x42, 0xa2, 0x03, 0x3b, 0xca, 0xca, 0xca, // 13c0 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xc4, 0x28, // 13c8 + 0x3b, 0xea, 0xea, 0x08, 0xc9, 0xc4, 0xd0, 0xfe, // 13d0 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 13d8 + 0xff, 0x48, 0xa9, 0x6f, 0x28, 0x3b, 0xea, 0xea, // 13e0 + 0x08, 0xc9, 0x6f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 13e8 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 13f0 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 13f8 + 0x4b, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1400 + 0x48, 0xa9, 0xb4, 0x28, 0x4b, 0xea, 0xea, 0x08, // 1408 + 0xc9, 0xb4, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1410 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x5f, // 1418 + 0x28, 0x4b, 0xea, 0xea, 0x08, 0xc9, 0x5f, 0xd0, // 1420 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 1428 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 1430 + 0xa0, 0x42, 0xa2, 0x03, 0x5b, 0xca, 0xca, 0xca, // 1438 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0xa4, 0x28, // 1440 + 0x5b, 0xea, 0xea, 0x08, 0xc9, 0xa4, 0xd0, 0xfe, // 1448 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1450 + 0xff, 0x48, 0xa9, 0x4f, 0x28, 0x5b, 0xea, 0xea, // 1458 + 0x08, 0xc9, 0x4f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1460 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1468 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 1470 + 0x6b, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1478 + 0x48, 0xa9, 0x94, 0x28, 0x6b, 0xea, 0xea, 0x08, // 1480 + 0xc9, 0x94, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1488 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x3f, // 1490 + 0x28, 0x6b, 0xea, 0xea, 0x08, 0xc9, 0x3f, 0xd0, // 1498 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 14a0 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 14a8 + 0xa0, 0x42, 0xa2, 0x03, 0x7b, 0xca, 0xca, 0xca, // 14b0 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x84, 0x28, // 14b8 + 0x7b, 0xea, 0xea, 0x08, 0xc9, 0x84, 0xd0, 0xfe, // 14c0 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 14c8 + 0xff, 0x48, 0xa9, 0x2f, 0x28, 0x7b, 0xea, 0xea, // 14d0 + 0x08, 0xc9, 0x2f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 14d8 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 14e0 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 14e8 + 0x8b, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 14f0 + 0x48, 0xa9, 0x74, 0x28, 0x8b, 0xea, 0xea, 0x08, // 14f8 + 0xc9, 0x74, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1500 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x1f, // 1508 + 0x28, 0x8b, 0xea, 0xea, 0x08, 0xc9, 0x1f, 0xd0, // 1510 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 1518 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 1520 + 0xa0, 0x42, 0xa2, 0x03, 0x9b, 0xca, 0xca, 0xca, // 1528 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x64, 0x28, // 1530 + 0x9b, 0xea, 0xea, 0x08, 0xc9, 0x64, 0xd0, 0xfe, // 1538 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1540 + 0xff, 0x48, 0xa9, 0x0f, 0x28, 0x9b, 0xea, 0xea, // 1548 + 0x08, 0xc9, 0x0f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1550 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1558 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 1560 + 0xab, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 1568 + 0x48, 0xa9, 0x54, 0x28, 0xab, 0xea, 0xea, 0x08, // 1570 + 0xc9, 0x54, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1578 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xff, // 1580 + 0x28, 0xab, 0xea, 0xea, 0x08, 0xc9, 0xff, 0xd0, // 1588 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 1590 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 1598 + 0xa0, 0x42, 0xa2, 0x03, 0xbb, 0xca, 0xca, 0xca, // 15a0 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x44, 0x28, // 15a8 + 0xbb, 0xea, 0xea, 0x08, 0xc9, 0x44, 0xd0, 0xfe, // 15b0 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 15b8 + 0xff, 0x48, 0xa9, 0xef, 0x28, 0xbb, 0xea, 0xea, // 15c0 + 0x08, 0xc9, 0xef, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 15c8 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 15d0 + 0xe0, 0x00, 0xd0, 0xfe, 0xa0, 0x42, 0xa2, 0x03, // 15d8 + 0xeb, 0xca, 0xca, 0xca, 0xd0, 0xfe, 0xa9, 0x00, // 15e0 + 0x48, 0xa9, 0x14, 0x28, 0xeb, 0xea, 0xea, 0x08, // 15e8 + 0xc9, 0x14, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 15f0 + 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0xbf, // 15f8 + 0x28, 0xeb, 0xea, 0xea, 0x08, 0xc9, 0xbf, 0xd0, // 1600 + 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, // 1608 + 0xc0, 0x42, 0xd0, 0xfe, 0xe0, 0x00, 0xd0, 0xfe, // 1610 + 0xa0, 0x42, 0xa2, 0x03, 0xfb, 0xca, 0xca, 0xca, // 1618 + 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0xa9, 0x04, 0x28, // 1620 + 0xfb, 0xea, 0xea, 0x08, 0xc9, 0x04, 0xd0, 0xfe, // 1628 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa9, // 1630 + 0xff, 0x48, 0xa9, 0xaf, 0x28, 0xfb, 0xea, 0xea, // 1638 + 0x08, 0xc9, 0xaf, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1640 + 0xff, 0xd0, 0xfe, 0x28, 0xc0, 0x42, 0xd0, 0xfe, // 1648 + 0xe0, 0x00, 0xd0, 0xfe, 0xad, 0x02, 0x02, 0xc9, // 1650 + 0x08, 0xd0, 0xfe, 0xa9, 0x09, 0x8d, 0x02, 0x02, // 1658 + 0xa2, 0x03, 0xbd, 0x8b, 0x26, 0x9d, 0xfd, 0x02, // 1660 + 0xca, 0x10, 0xf7, 0xa9, 0x28, 0x8d, 0x00, 0x02, // 1668 + 0xa9, 0x00, 0x48, 0x28, 0xa9, 0x49, 0xa2, 0x4e, // 1670 + 0xa0, 0x44, 0x6c, 0xfd, 0x02, 0xea, 0xd0, 0xfe, // 1678 + 0x88, 0x88, 0x08, 0x88, 0x88, 0x88, 0x28, 0xf0, // 1680 + 0xfe, 0x10, 0xfe, 0x90, 0xfe, 0x50, 0xfe, 0xc9, // 1688 + 0xe3, 0xd0, 0xfe, 0xe0, 0x4f, 0xd0, 0xfe, 0xc0, // 1690 + 0x3e, 0xd0, 0xfe, 0xba, 0xe0, 0xff, 0xd0, 0xfe, // 1698 + 0xad, 0x02, 0x02, 0xc9, 0x09, 0xd0, 0xfe, 0xa9, // 16a0 + 0x0a, 0x8d, 0x02, 0x02, 0xa2, 0x0b, 0xbd, 0xc7, // 16a8 + 0x26, 0x9d, 0xf9, 0x02, 0xca, 0x10, 0xf7, 0xa9, // 16b0 + 0x27, 0x8d, 0x00, 0x02, 0xa9, 0x00, 0x48, 0x28, // 16b8 + 0xa9, 0x58, 0xa2, 0x04, 0xa0, 0x49, 0x7c, 0xf9, // 16c0 + 0x02, 0xea, 0xd0, 0xfe, 0x88, 0x88, 0x08, 0x88, // 16c8 + 0x88, 0x88, 0x28, 0xf0, 0xfe, 0x10, 0xfe, 0x90, // 16d0 + 0xfe, 0x50, 0xfe, 0xc9, 0xf2, 0xd0, 0xfe, 0xe0, // 16d8 + 0x06, 0xd0, 0xfe, 0xc0, 0x43, 0xd0, 0xfe, 0xba, // 16e0 + 0xe0, 0xff, 0xd0, 0xfe, 0xa9, 0x08, 0x8d, 0x00, // 16e8 + 0x03, 0xa9, 0x17, 0x8d, 0x01, 0x03, 0xa9, 0x05, // 16f0 + 0x8d, 0x00, 0x02, 0xa9, 0x17, 0x8d, 0x01, 0x02, // 16f8 + 0xa2, 0xff, 0x7c, 0x01, 0x02, 0x4c, 0x05, 0x17, // 1700 + 0xad, 0x02, 0x02, 0xc9, 0x0a, 0xd0, 0xfe, 0xa9, // 1708 + 0x0b, 0x8d, 0x02, 0x02, 0xa9, 0x00, 0x48, 0xa9, // 1710 + 0x42, 0xa2, 0x52, 0xa0, 0x4b, 0x28, 0x00, 0x88, // 1718 + 0x08, 0x88, 0x88, 0x88, 0xc9, 0xe8, 0xd0, 0xfe, // 1720 + 0xe0, 0x53, 0xd0, 0xfe, 0xc0, 0x45, 0xd0, 0xfe, // 1728 + 0x68, 0xc9, 0x30, 0xd0, 0xfe, 0xba, 0xe0, 0xff, // 1730 + 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0xa9, 0xbd, 0xa2, // 1738 + 0xad, 0xa0, 0xb4, 0x28, 0x00, 0x88, 0x08, 0x88, // 1740 + 0x88, 0x88, 0xc9, 0x17, 0xd0, 0xfe, 0xe0, 0xae, // 1748 + 0xd0, 0xfe, 0xc0, 0xae, 0xd0, 0xfe, 0x68, 0xc9, // 1750 + 0xff, 0xd0, 0xfe, 0xba, 0xe0, 0xff, 0xd0, 0xfe, // 1758 + 0xad, 0x02, 0x02, 0xc9, 0x0b, 0xd0, 0xfe, 0xa9, // 1760 + 0x0c, 0x8d, 0x02, 0x02, 0xa2, 0xac, 0xa0, 0xdc, // 1768 + 0xa9, 0xff, 0x48, 0xa9, 0xfe, 0x28, 0x1a, 0x48, // 1770 + 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1778 + 0xfd, 0xd0, 0xfe, 0x28, 0x68, 0x1a, 0x48, 0x08, // 1780 + 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, // 1788 + 0xd0, 0xfe, 0x28, 0x68, 0x1a, 0x48, 0x08, 0xc9, // 1790 + 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7d, 0xd0, // 1798 + 0xfe, 0x28, 0x68, 0x3a, 0x48, 0x08, 0xc9, 0x00, // 17a0 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7f, 0xd0, 0xfe, // 17a8 + 0x28, 0x68, 0x3a, 0x48, 0x08, 0xc9, 0xff, 0xd0, // 17b0 + 0xfe, 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, 0x28, // 17b8 + 0x68, 0x3a, 0xa9, 0x00, 0x48, 0xa9, 0xfe, 0x28, // 17c0 + 0x1a, 0x48, 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, // 17c8 + 0x48, 0xc9, 0xb0, 0xd0, 0xfe, 0x28, 0x68, 0x1a, // 17d0 + 0x48, 0x08, 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x48, // 17d8 + 0xc9, 0x32, 0xd0, 0xfe, 0x28, 0x68, 0x1a, 0x48, // 17e0 + 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 17e8 + 0x30, 0xd0, 0xfe, 0x28, 0x68, 0x3a, 0x48, 0x08, // 17f0 + 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x32, // 17f8 + 0xd0, 0xfe, 0x28, 0x68, 0x3a, 0x48, 0x08, 0xc9, // 1800 + 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb0, 0xd0, // 1808 + 0xfe, 0x28, 0x68, 0xe0, 0xac, 0xd0, 0xfe, 0xc0, // 1810 + 0xdc, 0xd0, 0xfe, 0xba, 0xe0, 0xff, 0xd0, 0xfe, // 1818 + 0xad, 0x02, 0x02, 0xc9, 0x0c, 0xd0, 0xfe, 0xa9, // 1820 + 0x0d, 0x8d, 0x02, 0x02, 0xa2, 0x99, 0xa0, 0x66, // 1828 + 0xa9, 0x00, 0x48, 0x28, 0xb2, 0x24, 0x08, 0x49, // 1830 + 0xc3, 0x28, 0x92, 0x30, 0x08, 0x49, 0xc3, 0xc9, // 1838 + 0xc3, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x15, // 1840 + 0x02, 0xd0, 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xb2, // 1848 + 0x26, 0x08, 0x49, 0xc3, 0x28, 0x92, 0x32, 0x08, // 1850 + 0x49, 0xc3, 0xc9, 0x82, 0xd0, 0xfe, 0x68, 0x49, // 1858 + 0x30, 0xcd, 0x16, 0x02, 0xd0, 0xfe, 0xa9, 0x00, // 1860 + 0x48, 0x28, 0xb2, 0x28, 0x08, 0x49, 0xc3, 0x28, // 1868 + 0x92, 0x34, 0x08, 0x49, 0xc3, 0xc9, 0x41, 0xd0, // 1870 + 0xfe, 0x68, 0x49, 0x30, 0xcd, 0x17, 0x02, 0xd0, // 1878 + 0xfe, 0xa9, 0x00, 0x48, 0x28, 0xb2, 0x2a, 0x08, // 1880 + 0x49, 0xc3, 0x28, 0x92, 0x36, 0x08, 0x49, 0xc3, // 1888 + 0xc9, 0x00, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xcd, // 1890 + 0x18, 0x02, 0xd0, 0xfe, 0xe0, 0x99, 0xd0, 0xfe, // 1898 + 0xc0, 0x66, 0xd0, 0xfe, 0xa0, 0x03, 0xa2, 0x00, // 18a0 + 0xb9, 0x05, 0x02, 0x49, 0xc3, 0xd9, 0x10, 0x02, // 18a8 + 0xd0, 0xfe, 0x8a, 0x99, 0x05, 0x02, 0x88, 0x10, // 18b0 + 0xef, 0xa2, 0x99, 0xa0, 0x66, 0xa9, 0xff, 0x48, // 18b8 + 0x28, 0xb2, 0x24, 0x08, 0x49, 0xc3, 0x28, 0x92, // 18c0 + 0x30, 0x08, 0x49, 0xc3, 0xc9, 0xc3, 0xd0, 0xfe, // 18c8 + 0x68, 0x49, 0x7d, 0xcd, 0x15, 0x02, 0xd0, 0xfe, // 18d0 + 0xa9, 0xff, 0x48, 0x28, 0xb2, 0x26, 0x08, 0x49, // 18d8 + 0xc3, 0x28, 0x92, 0x32, 0x08, 0x49, 0xc3, 0xc9, // 18e0 + 0x82, 0xd0, 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x16, // 18e8 + 0x02, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0x28, 0xb2, // 18f0 + 0x28, 0x08, 0x49, 0xc3, 0x28, 0x92, 0x34, 0x08, // 18f8 + 0x49, 0xc3, 0xc9, 0x41, 0xd0, 0xfe, 0x68, 0x49, // 1900 + 0x7d, 0xcd, 0x17, 0x02, 0xd0, 0xfe, 0xa9, 0xff, // 1908 + 0x48, 0x28, 0xb2, 0x2a, 0x08, 0x49, 0xc3, 0x28, // 1910 + 0x92, 0x36, 0x08, 0x49, 0xc3, 0xc9, 0x00, 0xd0, // 1918 + 0xfe, 0x68, 0x49, 0x7d, 0xcd, 0x18, 0x02, 0xd0, // 1920 + 0xfe, 0xe0, 0x99, 0xd0, 0xfe, 0xc0, 0x66, 0xd0, // 1928 + 0xfe, 0xa0, 0x03, 0xa2, 0x00, 0xb9, 0x05, 0x02, // 1930 + 0x49, 0xc3, 0xd9, 0x10, 0x02, 0xd0, 0xfe, 0x8a, // 1938 + 0x99, 0x05, 0x02, 0x88, 0x10, 0xef, 0xba, 0xe0, // 1940 + 0xff, 0xd0, 0xfe, 0xad, 0x02, 0x02, 0xc9, 0x0d, // 1948 + 0xd0, 0xfe, 0xa9, 0x0e, 0x8d, 0x02, 0x02, 0xa0, // 1950 + 0x7b, 0xa2, 0x04, 0xa9, 0x07, 0x95, 0x0c, 0x0a, // 1958 + 0xca, 0x10, 0xfa, 0xa2, 0x04, 0xa9, 0xff, 0x48, // 1960 + 0xa9, 0x55, 0x28, 0x64, 0x0c, 0x64, 0x0d, 0x64, // 1968 + 0x0e, 0x64, 0x0f, 0x64, 0x10, 0x08, 0xc9, 0x55, // 1970 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, // 1978 + 0x28, 0xb5, 0x0c, 0xd0, 0xfe, 0xca, 0x10, 0xf9, // 1980 + 0xa2, 0x04, 0xa9, 0x07, 0x95, 0x0c, 0x0a, 0xca, // 1988 + 0x10, 0xfa, 0xa2, 0x04, 0xa9, 0x00, 0x48, 0xa9, // 1990 + 0xaa, 0x28, 0x64, 0x0c, 0x64, 0x0d, 0x64, 0x0e, // 1998 + 0x64, 0x0f, 0x64, 0x10, 0x08, 0xc9, 0xaa, 0xd0, // 19a0 + 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, // 19a8 + 0xb5, 0x0c, 0xd0, 0xfe, 0xca, 0x10, 0xf9, 0xa2, // 19b0 + 0x04, 0xa9, 0x07, 0x9d, 0x05, 0x02, 0x0a, 0xca, // 19b8 + 0x10, 0xf9, 0xa2, 0x04, 0xa9, 0xff, 0x48, 0xa9, // 19c0 + 0x55, 0x28, 0x9c, 0x05, 0x02, 0x9c, 0x06, 0x02, // 19c8 + 0x9c, 0x07, 0x02, 0x9c, 0x08, 0x02, 0x9c, 0x09, // 19d0 + 0x02, 0x08, 0xc9, 0x55, 0xd0, 0xfe, 0x68, 0x48, // 19d8 + 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xbd, 0x05, 0x02, // 19e0 + 0xd0, 0xfe, 0xca, 0x10, 0xf8, 0xa2, 0x04, 0xa9, // 19e8 + 0x07, 0x9d, 0x05, 0x02, 0x0a, 0xca, 0x10, 0xf9, // 19f0 + 0xa2, 0x04, 0xa9, 0x00, 0x48, 0xa9, 0xaa, 0x28, // 19f8 + 0x9c, 0x05, 0x02, 0x9c, 0x06, 0x02, 0x9c, 0x07, // 1a00 + 0x02, 0x9c, 0x08, 0x02, 0x9c, 0x09, 0x02, 0x08, // 1a08 + 0xc9, 0xaa, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1a10 + 0xd0, 0xfe, 0x28, 0xbd, 0x05, 0x02, 0xd0, 0xfe, // 1a18 + 0xca, 0x10, 0xf8, 0xa2, 0x04, 0xa9, 0x07, 0x95, // 1a20 + 0x0c, 0x0a, 0xca, 0x10, 0xfa, 0xa2, 0x04, 0xa9, // 1a28 + 0xff, 0x48, 0xa9, 0x55, 0x28, 0x74, 0x0c, 0x08, // 1a30 + 0xc9, 0x55, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 1a38 + 0xd0, 0xfe, 0x28, 0xca, 0x10, 0xe9, 0xa2, 0x04, // 1a40 + 0xb5, 0x0c, 0xd0, 0xfe, 0xca, 0x10, 0xf9, 0xa2, // 1a48 + 0x04, 0xa9, 0x07, 0x95, 0x0c, 0x0a, 0xca, 0x10, // 1a50 + 0xfa, 0xa2, 0x04, 0xa9, 0x00, 0x48, 0xa9, 0xaa, // 1a58 + 0x28, 0x74, 0x0c, 0x08, 0xc9, 0xaa, 0xd0, 0xfe, // 1a60 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xca, // 1a68 + 0x10, 0xe9, 0xa2, 0x04, 0xb5, 0x0c, 0xd0, 0xfe, // 1a70 + 0xca, 0x10, 0xf9, 0xa2, 0x04, 0xa9, 0x07, 0x9d, // 1a78 + 0x05, 0x02, 0x0a, 0xca, 0x10, 0xf9, 0xa2, 0x04, // 1a80 + 0xa9, 0xff, 0x48, 0xa9, 0x55, 0x28, 0x9e, 0x05, // 1a88 + 0x02, 0x08, 0xc9, 0x55, 0xd0, 0xfe, 0x68, 0x48, // 1a90 + 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xca, 0x10, 0xe8, // 1a98 + 0xa2, 0x04, 0xbd, 0x05, 0x02, 0xd0, 0xfe, 0xca, // 1aa0 + 0x10, 0xf8, 0xa2, 0x04, 0xa9, 0x07, 0x9d, 0x05, // 1aa8 + 0x02, 0x0a, 0xca, 0x10, 0xf9, 0xa2, 0x04, 0xa9, // 1ab0 + 0x00, 0x48, 0xa9, 0xaa, 0x28, 0x9e, 0x05, 0x02, // 1ab8 + 0x08, 0xc9, 0xaa, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1ac0 + 0x30, 0xd0, 0xfe, 0x28, 0xca, 0x10, 0xe8, 0xa2, // 1ac8 + 0x04, 0xbd, 0x05, 0x02, 0xd0, 0xfe, 0xca, 0x10, // 1ad0 + 0xf8, 0xc0, 0x7b, 0xd0, 0xfe, 0xba, 0xe0, 0xff, // 1ad8 + 0xd0, 0xfe, 0xad, 0x02, 0x02, 0xc9, 0x0e, 0xd0, // 1ae0 + 0xfe, 0xa9, 0x0f, 0x8d, 0x02, 0x02, 0xa0, 0x42, // 1ae8 + 0xa2, 0x03, 0xa9, 0x00, 0x48, 0xa9, 0xff, 0x28, // 1af0 + 0x34, 0x13, 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, // 1af8 + 0x48, 0xc9, 0x32, 0xd0, 0xfe, 0x28, 0xca, 0xa9, // 1b00 + 0x00, 0x48, 0xa9, 0x01, 0x28, 0x34, 0x13, 0x08, // 1b08 + 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x70, // 1b10 + 0xd0, 0xfe, 0x28, 0xca, 0xa9, 0x00, 0x48, 0xa9, // 1b18 + 0x01, 0x28, 0x34, 0x13, 0x08, 0xc9, 0x01, 0xd0, // 1b20 + 0xfe, 0x68, 0x48, 0xc9, 0xb2, 0xd0, 0xfe, 0x28, // 1b28 + 0xca, 0xa9, 0x00, 0x48, 0xa9, 0x01, 0x28, 0x34, // 1b30 + 0x13, 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, // 1b38 + 0xc9, 0xf0, 0xd0, 0xfe, 0x28, 0xa9, 0xff, 0x48, // 1b40 + 0xa9, 0x01, 0x28, 0x34, 0x13, 0x08, 0xc9, 0x01, // 1b48 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, // 1b50 + 0x28, 0xe8, 0xa9, 0xff, 0x48, 0xa9, 0x01, 0x28, // 1b58 + 0x34, 0x13, 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, // 1b60 + 0x48, 0xc9, 0xbf, 0xd0, 0xfe, 0x28, 0xe8, 0xa9, // 1b68 + 0xff, 0x48, 0xa9, 0x01, 0x28, 0x34, 0x13, 0x08, // 1b70 + 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7d, // 1b78 + 0xd0, 0xfe, 0x28, 0xe8, 0xa9, 0xff, 0x48, 0xa9, // 1b80 + 0xff, 0x28, 0x34, 0x13, 0x08, 0xc9, 0xff, 0xd0, // 1b88 + 0xfe, 0x68, 0x48, 0xc9, 0x3f, 0xd0, 0xfe, 0x28, // 1b90 + 0xa9, 0x00, 0x48, 0xa9, 0xff, 0x28, 0x3c, 0x10, // 1b98 + 0x02, 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, // 1ba0 + 0xc9, 0x32, 0xd0, 0xfe, 0x28, 0xca, 0xa9, 0x00, // 1ba8 + 0x48, 0xa9, 0x01, 0x28, 0x3c, 0x10, 0x02, 0x08, // 1bb0 + 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x70, // 1bb8 + 0xd0, 0xfe, 0x28, 0xca, 0xa9, 0x00, 0x48, 0xa9, // 1bc0 + 0x01, 0x28, 0x3c, 0x10, 0x02, 0x08, 0xc9, 0x01, // 1bc8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xb2, 0xd0, 0xfe, // 1bd0 + 0x28, 0xca, 0xa9, 0x00, 0x48, 0xa9, 0x01, 0x28, // 1bd8 + 0x3c, 0x10, 0x02, 0x08, 0xc9, 0x01, 0xd0, 0xfe, // 1be0 + 0x68, 0x48, 0xc9, 0xf0, 0xd0, 0xfe, 0x28, 0xa9, // 1be8 + 0xff, 0x48, 0xa9, 0x01, 0x28, 0x3c, 0x10, 0x02, // 1bf0 + 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1bf8 + 0xfd, 0xd0, 0xfe, 0x28, 0xe8, 0xa9, 0xff, 0x48, // 1c00 + 0xa9, 0x01, 0x28, 0x3c, 0x10, 0x02, 0x08, 0xc9, // 1c08 + 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xbf, 0xd0, // 1c10 + 0xfe, 0x28, 0xe8, 0xa9, 0xff, 0x48, 0xa9, 0x01, // 1c18 + 0x28, 0x3c, 0x10, 0x02, 0x08, 0xc9, 0x01, 0xd0, // 1c20 + 0xfe, 0x68, 0x48, 0xc9, 0x7d, 0xd0, 0xfe, 0x28, // 1c28 + 0xe8, 0xa9, 0xff, 0x48, 0xa9, 0xff, 0x28, 0x3c, // 1c30 + 0x10, 0x02, 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, // 1c38 + 0x48, 0xc9, 0x3f, 0xd0, 0xfe, 0x28, 0xa9, 0x00, // 1c40 + 0x48, 0xa9, 0xff, 0x28, 0x89, 0x00, 0x08, 0xc9, // 1c48 + 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x32, 0xd0, // 1c50 + 0xfe, 0x28, 0xca, 0xa9, 0x00, 0x48, 0xa9, 0x01, // 1c58 + 0x28, 0x89, 0x41, 0x08, 0xc9, 0x01, 0xd0, 0xfe, // 1c60 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xca, // 1c68 + 0xa9, 0x00, 0x48, 0xa9, 0x01, 0x28, 0x89, 0x82, // 1c70 + 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1c78 + 0x32, 0xd0, 0xfe, 0x28, 0xca, 0xa9, 0x00, 0x48, // 1c80 + 0xa9, 0x01, 0x28, 0x89, 0xc3, 0x08, 0xc9, 0x01, // 1c88 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 1c90 + 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x01, 0x28, 0x89, // 1c98 + 0xc3, 0x08, 0xc9, 0x01, 0xd0, 0xfe, 0x68, 0x48, // 1ca0 + 0xc9, 0xfd, 0xd0, 0xfe, 0x28, 0xe8, 0xa9, 0xff, // 1ca8 + 0x48, 0xa9, 0x01, 0x28, 0x89, 0x82, 0x08, 0xc9, // 1cb0 + 0x01, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, // 1cb8 + 0xfe, 0x28, 0xe8, 0xa9, 0xff, 0x48, 0xa9, 0x01, // 1cc0 + 0x28, 0x89, 0x41, 0x08, 0xc9, 0x01, 0xd0, 0xfe, // 1cc8 + 0x68, 0x48, 0xc9, 0xfd, 0xd0, 0xfe, 0x28, 0xe8, // 1cd0 + 0xa9, 0xff, 0x48, 0xa9, 0xff, 0x28, 0x89, 0x00, // 1cd8 + 0x08, 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x48, 0xc9, // 1ce0 + 0xff, 0xd0, 0xfe, 0x28, 0xe0, 0x03, 0xd0, 0xfe, // 1ce8 + 0xc0, 0x42, 0xd0, 0xfe, 0xba, 0xe0, 0xff, 0xd0, // 1cf0 + 0xfe, 0xad, 0x02, 0x02, 0xc9, 0x0f, 0xd0, 0xfe, // 1cf8 + 0xa9, 0x10, 0x8d, 0x02, 0x02, 0xa2, 0xc0, 0xa0, // 1d00 + 0x00, 0x64, 0x0d, 0x98, 0x25, 0x0d, 0x08, 0x68, // 1d08 + 0x29, 0x02, 0x85, 0x0e, 0x98, 0x49, 0xff, 0x05, // 1d10 + 0x0d, 0x49, 0xff, 0x85, 0x0f, 0x98, 0x05, 0x0d, // 1d18 + 0x85, 0x10, 0x84, 0x0c, 0xa9, 0xff, 0x48, 0xa5, // 1d20 + 0x0d, 0x28, 0x14, 0x0c, 0x08, 0xc5, 0x0d, 0xd0, // 1d28 + 0xfe, 0x68, 0x48, 0x09, 0x02, 0xc9, 0xff, 0xd0, // 1d30 + 0xfe, 0x68, 0x29, 0x02, 0xc5, 0x0e, 0xd0, 0xfe, // 1d38 + 0xa5, 0x0f, 0xc5, 0x0c, 0xd0, 0xfe, 0x8c, 0x05, // 1d40 + 0x02, 0xa9, 0xff, 0x48, 0xa5, 0x0d, 0x28, 0x1c, // 1d48 + 0x05, 0x02, 0x08, 0xc5, 0x0d, 0xd0, 0xfe, 0x68, // 1d50 + 0x48, 0x09, 0x02, 0xc9, 0xff, 0xd0, 0xfe, 0x68, // 1d58 + 0x29, 0x02, 0xc5, 0x0e, 0xd0, 0xfe, 0xa5, 0x0f, // 1d60 + 0xc5, 0x0c, 0xd0, 0xfe, 0x84, 0x0c, 0xa9, 0x00, // 1d68 + 0x48, 0xa5, 0x0d, 0x28, 0x14, 0x0c, 0x08, 0xc5, // 1d70 + 0x0d, 0xd0, 0xfe, 0x68, 0x48, 0x09, 0x02, 0xc9, // 1d78 + 0x32, 0xd0, 0xfe, 0x68, 0x29, 0x02, 0xc5, 0x0e, // 1d80 + 0xd0, 0xfe, 0xa5, 0x0f, 0xc5, 0x0c, 0xd0, 0xfe, // 1d88 + 0x8c, 0x05, 0x02, 0xa9, 0x00, 0x48, 0xa5, 0x0d, // 1d90 + 0x28, 0x1c, 0x05, 0x02, 0x08, 0xc5, 0x0d, 0xd0, // 1d98 + 0xfe, 0x68, 0x48, 0x09, 0x02, 0xc9, 0x32, 0xd0, // 1da0 + 0xfe, 0x68, 0x29, 0x02, 0xc5, 0x0e, 0xd0, 0xfe, // 1da8 + 0xa5, 0x0f, 0xc5, 0x0c, 0xd0, 0xfe, 0x84, 0x0c, // 1db0 + 0xa9, 0xff, 0x48, 0xa5, 0x0d, 0x28, 0x04, 0x0c, // 1db8 + 0x08, 0xc5, 0x0d, 0xd0, 0xfe, 0x68, 0x48, 0x09, // 1dc0 + 0x02, 0xc9, 0xff, 0xd0, 0xfe, 0x68, 0x29, 0x02, // 1dc8 + 0xc5, 0x0e, 0xd0, 0xfe, 0xa5, 0x10, 0xc5, 0x0c, // 1dd0 + 0xd0, 0xfe, 0x8c, 0x05, 0x02, 0xa9, 0xff, 0x48, // 1dd8 + 0xa5, 0x0d, 0x28, 0x0c, 0x05, 0x02, 0x08, 0xc5, // 1de0 + 0x0d, 0xd0, 0xfe, 0x68, 0x48, 0x09, 0x02, 0xc9, // 1de8 + 0xff, 0xd0, 0xfe, 0x68, 0x29, 0x02, 0xc5, 0x0e, // 1df0 + 0xd0, 0xfe, 0xa5, 0x10, 0xc5, 0x0c, 0xd0, 0xfe, // 1df8 + 0x84, 0x0c, 0xa9, 0x00, 0x48, 0xa5, 0x0d, 0x28, // 1e00 + 0x04, 0x0c, 0x08, 0xc5, 0x0d, 0xd0, 0xfe, 0x68, // 1e08 + 0x48, 0x09, 0x02, 0xc9, 0x32, 0xd0, 0xfe, 0x68, // 1e10 + 0x29, 0x02, 0xc5, 0x0e, 0xd0, 0xfe, 0xa5, 0x10, // 1e18 + 0xc5, 0x0c, 0xd0, 0xfe, 0x8c, 0x05, 0x02, 0xa9, // 1e20 + 0x00, 0x48, 0xa5, 0x0d, 0x28, 0x0c, 0x05, 0x02, // 1e28 + 0x08, 0xc5, 0x0d, 0xd0, 0xfe, 0x68, 0x48, 0x09, // 1e30 + 0x02, 0xc9, 0x32, 0xd0, 0xfe, 0x68, 0x29, 0x02, // 1e38 + 0xc5, 0x0e, 0xd0, 0xfe, 0xa5, 0x10, 0xc5, 0x0c, // 1e40 + 0xd0, 0xfe, 0xc8, 0xd0, 0x04, 0xe6, 0x0d, 0xf0, // 1e48 + 0x03, 0x4c, 0x0b, 0x1d, 0xe0, 0xc0, 0xd0, 0xfe, // 1e50 + 0xba, 0xe0, 0xff, 0xd0, 0xfe, 0xad, 0x02, 0x02, // 1e58 + 0xc9, 0x10, 0xd0, 0xfe, 0xa9, 0x11, 0x8d, 0x02, // 1e60 + 0x02, 0xa2, 0xba, 0xa0, 0xd0, 0xa9, 0xff, 0x85, // 1e68 + 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0xa5, 0x28, 0x07, // 1e70 + 0x0c, 0x08, 0xc9, 0xa5, 0xd0, 0xfe, 0x68, 0x48, // 1e78 + 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, // 1e80 + 0xfe, 0xd0, 0xfe, 0xa9, 0x01, 0x85, 0x0c, 0xa9, // 1e88 + 0xff, 0x48, 0xa9, 0x5a, 0x28, 0x07, 0x0c, 0x08, // 1e90 + 0xc9, 0x5a, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 1e98 + 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xd0, 0xfe, 0xa9, // 1ea0 + 0xff, 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0xa5, // 1ea8 + 0x28, 0x17, 0x0c, 0x08, 0xc9, 0xa5, 0xd0, 0xfe, // 1eb0 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa5, // 1eb8 + 0x0c, 0xc9, 0xfd, 0xd0, 0xfe, 0xa9, 0x02, 0x85, // 1ec0 + 0x0c, 0xa9, 0xff, 0x48, 0xa9, 0x5a, 0x28, 0x17, // 1ec8 + 0x0c, 0x08, 0xc9, 0x5a, 0xd0, 0xfe, 0x68, 0x48, // 1ed0 + 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xd0, // 1ed8 + 0xfe, 0xa9, 0xff, 0x85, 0x0c, 0xa9, 0x00, 0x48, // 1ee0 + 0xa9, 0xa5, 0x28, 0x27, 0x0c, 0x08, 0xc9, 0xa5, // 1ee8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 1ef0 + 0x28, 0xa5, 0x0c, 0xc9, 0xfb, 0xd0, 0xfe, 0xa9, // 1ef8 + 0x04, 0x85, 0x0c, 0xa9, 0xff, 0x48, 0xa9, 0x5a, // 1f00 + 0x28, 0x27, 0x0c, 0x08, 0xc9, 0x5a, 0xd0, 0xfe, // 1f08 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, // 1f10 + 0x0c, 0xd0, 0xfe, 0xa9, 0xff, 0x85, 0x0c, 0xa9, // 1f18 + 0x00, 0x48, 0xa9, 0xa5, 0x28, 0x37, 0x0c, 0x08, // 1f20 + 0xc9, 0xa5, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 1f28 + 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0xf7, 0xd0, // 1f30 + 0xfe, 0xa9, 0x08, 0x85, 0x0c, 0xa9, 0xff, 0x48, // 1f38 + 0xa9, 0x5a, 0x28, 0x37, 0x0c, 0x08, 0xc9, 0x5a, // 1f40 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, // 1f48 + 0x28, 0xa5, 0x0c, 0xd0, 0xfe, 0xa9, 0xff, 0x85, // 1f50 + 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0xa5, 0x28, 0x47, // 1f58 + 0x0c, 0x08, 0xc9, 0xa5, 0xd0, 0xfe, 0x68, 0x48, // 1f60 + 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, // 1f68 + 0xef, 0xd0, 0xfe, 0xa9, 0x10, 0x85, 0x0c, 0xa9, // 1f70 + 0xff, 0x48, 0xa9, 0x5a, 0x28, 0x47, 0x0c, 0x08, // 1f78 + 0xc9, 0x5a, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 1f80 + 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xd0, 0xfe, 0xa9, // 1f88 + 0xff, 0x85, 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0xa5, // 1f90 + 0x28, 0x57, 0x0c, 0x08, 0xc9, 0xa5, 0xd0, 0xfe, // 1f98 + 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa5, // 1fa0 + 0x0c, 0xc9, 0xdf, 0xd0, 0xfe, 0xa9, 0x20, 0x85, // 1fa8 + 0x0c, 0xa9, 0xff, 0x48, 0xa9, 0x5a, 0x28, 0x57, // 1fb0 + 0x0c, 0x08, 0xc9, 0x5a, 0xd0, 0xfe, 0x68, 0x48, // 1fb8 + 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xd0, // 1fc0 + 0xfe, 0xa9, 0xff, 0x85, 0x0c, 0xa9, 0x00, 0x48, // 1fc8 + 0xa9, 0xa5, 0x28, 0x67, 0x0c, 0x08, 0xc9, 0xa5, // 1fd0 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 1fd8 + 0x28, 0xa5, 0x0c, 0xc9, 0xbf, 0xd0, 0xfe, 0xa9, // 1fe0 + 0x40, 0x85, 0x0c, 0xa9, 0xff, 0x48, 0xa9, 0x5a, // 1fe8 + 0x28, 0x67, 0x0c, 0x08, 0xc9, 0x5a, 0xd0, 0xfe, // 1ff0 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, // 1ff8 + 0x0c, 0xd0, 0xfe, 0xa9, 0xff, 0x85, 0x0c, 0xa9, // 2000 + 0x00, 0x48, 0xa9, 0xa5, 0x28, 0x77, 0x0c, 0x08, // 2008 + 0xc9, 0xa5, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, // 2010 + 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x7f, 0xd0, // 2018 + 0xfe, 0xa9, 0x80, 0x85, 0x0c, 0xa9, 0xff, 0x48, // 2020 + 0xa9, 0x5a, 0x28, 0x77, 0x0c, 0x08, 0xc9, 0x5a, // 2028 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, // 2030 + 0x28, 0xa5, 0x0c, 0xd0, 0xfe, 0xa9, 0xfe, 0x85, // 2038 + 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0xa5, 0x28, 0x87, // 2040 + 0x0c, 0x08, 0xc9, 0xa5, 0xd0, 0xfe, 0x68, 0x48, // 2048 + 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, // 2050 + 0xff, 0xd0, 0xfe, 0xa9, 0x00, 0x85, 0x0c, 0xa9, // 2058 + 0xff, 0x48, 0xa9, 0x5a, 0x28, 0x87, 0x0c, 0x08, // 2060 + 0xc9, 0x5a, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 2068 + 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x01, 0xd0, // 2070 + 0xfe, 0xa9, 0xfd, 0x85, 0x0c, 0xa9, 0x00, 0x48, // 2078 + 0xa9, 0xa5, 0x28, 0x97, 0x0c, 0x08, 0xc9, 0xa5, // 2080 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 2088 + 0x28, 0xa5, 0x0c, 0xc9, 0xff, 0xd0, 0xfe, 0xa9, // 2090 + 0x00, 0x85, 0x0c, 0xa9, 0xff, 0x48, 0xa9, 0x5a, // 2098 + 0x28, 0x97, 0x0c, 0x08, 0xc9, 0x5a, 0xd0, 0xfe, // 20a0 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, // 20a8 + 0x0c, 0xc9, 0x02, 0xd0, 0xfe, 0xa9, 0xfb, 0x85, // 20b0 + 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0xa5, 0x28, 0xa7, // 20b8 + 0x0c, 0x08, 0xc9, 0xa5, 0xd0, 0xfe, 0x68, 0x48, // 20c0 + 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, // 20c8 + 0xff, 0xd0, 0xfe, 0xa9, 0x00, 0x85, 0x0c, 0xa9, // 20d0 + 0xff, 0x48, 0xa9, 0x5a, 0x28, 0xa7, 0x0c, 0x08, // 20d8 + 0xc9, 0x5a, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 20e0 + 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x04, 0xd0, // 20e8 + 0xfe, 0xa9, 0xf7, 0x85, 0x0c, 0xa9, 0x00, 0x48, // 20f0 + 0xa9, 0xa5, 0x28, 0xb7, 0x0c, 0x08, 0xc9, 0xa5, // 20f8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 2100 + 0x28, 0xa5, 0x0c, 0xc9, 0xff, 0xd0, 0xfe, 0xa9, // 2108 + 0x00, 0x85, 0x0c, 0xa9, 0xff, 0x48, 0xa9, 0x5a, // 2110 + 0x28, 0xb7, 0x0c, 0x08, 0xc9, 0x5a, 0xd0, 0xfe, // 2118 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, // 2120 + 0x0c, 0xc9, 0x08, 0xd0, 0xfe, 0xa9, 0xef, 0x85, // 2128 + 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0xa5, 0x28, 0xc7, // 2130 + 0x0c, 0x08, 0xc9, 0xa5, 0xd0, 0xfe, 0x68, 0x48, // 2138 + 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, // 2140 + 0xff, 0xd0, 0xfe, 0xa9, 0x00, 0x85, 0x0c, 0xa9, // 2148 + 0xff, 0x48, 0xa9, 0x5a, 0x28, 0xc7, 0x0c, 0x08, // 2150 + 0xc9, 0x5a, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 2158 + 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x10, 0xd0, // 2160 + 0xfe, 0xa9, 0xdf, 0x85, 0x0c, 0xa9, 0x00, 0x48, // 2168 + 0xa9, 0xa5, 0x28, 0xd7, 0x0c, 0x08, 0xc9, 0xa5, // 2170 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 2178 + 0x28, 0xa5, 0x0c, 0xc9, 0xff, 0xd0, 0xfe, 0xa9, // 2180 + 0x00, 0x85, 0x0c, 0xa9, 0xff, 0x48, 0xa9, 0x5a, // 2188 + 0x28, 0xd7, 0x0c, 0x08, 0xc9, 0x5a, 0xd0, 0xfe, // 2190 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, // 2198 + 0x0c, 0xc9, 0x20, 0xd0, 0xfe, 0xa9, 0xbf, 0x85, // 21a0 + 0x0c, 0xa9, 0x00, 0x48, 0xa9, 0xa5, 0x28, 0xe7, // 21a8 + 0x0c, 0x08, 0xc9, 0xa5, 0xd0, 0xfe, 0x68, 0x48, // 21b0 + 0xc9, 0x30, 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, // 21b8 + 0xff, 0xd0, 0xfe, 0xa9, 0x00, 0x85, 0x0c, 0xa9, // 21c0 + 0xff, 0x48, 0xa9, 0x5a, 0x28, 0xe7, 0x0c, 0x08, // 21c8 + 0xc9, 0x5a, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xff, // 21d0 + 0xd0, 0xfe, 0x28, 0xa5, 0x0c, 0xc9, 0x40, 0xd0, // 21d8 + 0xfe, 0xa9, 0x7f, 0x85, 0x0c, 0xa9, 0x00, 0x48, // 21e0 + 0xa9, 0xa5, 0x28, 0xf7, 0x0c, 0x08, 0xc9, 0xa5, // 21e8 + 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x30, 0xd0, 0xfe, // 21f0 + 0x28, 0xa5, 0x0c, 0xc9, 0xff, 0xd0, 0xfe, 0xa9, // 21f8 + 0x00, 0x85, 0x0c, 0xa9, 0xff, 0x48, 0xa9, 0x5a, // 2200 + 0x28, 0xf7, 0x0c, 0x08, 0xc9, 0x5a, 0xd0, 0xfe, // 2208 + 0x68, 0x48, 0xc9, 0xff, 0xd0, 0xfe, 0x28, 0xa5, // 2210 + 0x0c, 0xc9, 0x80, 0xd0, 0xfe, 0xe0, 0xba, 0xd0, // 2218 + 0xfe, 0xc0, 0xd0, 0xd0, 0xfe, 0xba, 0xe0, 0xff, // 2220 + 0xd0, 0xfe, 0xad, 0x02, 0x02, 0xc9, 0x11, 0xd0, // 2228 + 0xfe, 0xa9, 0x12, 0x8d, 0x02, 0x02, 0xa2, 0xde, // 2230 + 0xa0, 0xad, 0xa9, 0x00, 0x48, 0xa9, 0x80, 0x28, // 2238 + 0xd2, 0x2c, 0x08, 0xc9, 0x80, 0xd0, 0xfe, 0x68, // 2240 + 0x48, 0xc9, 0x31, 0xd0, 0xfe, 0x28, 0xa9, 0x00, // 2248 + 0x48, 0xa9, 0x7f, 0x28, 0xd2, 0x2c, 0x08, 0xc9, // 2250 + 0x7f, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x33, 0xd0, // 2258 + 0xfe, 0x28, 0xa9, 0x00, 0x48, 0xa9, 0x7e, 0x28, // 2260 + 0xd2, 0x2c, 0x08, 0xc9, 0x7e, 0xd0, 0xfe, 0x68, // 2268 + 0x48, 0xc9, 0xb0, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 2270 + 0x48, 0xa9, 0x80, 0x28, 0xd2, 0x2c, 0x08, 0xc9, // 2278 + 0x80, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0x7d, 0xd0, // 2280 + 0xfe, 0x28, 0xa9, 0xff, 0x48, 0xa9, 0x7f, 0x28, // 2288 + 0xd2, 0x2c, 0x08, 0xc9, 0x7f, 0xd0, 0xfe, 0x68, // 2290 + 0x48, 0xc9, 0x7f, 0xd0, 0xfe, 0x28, 0xa9, 0xff, // 2298 + 0x48, 0xa9, 0x7e, 0x28, 0xd2, 0x2c, 0x08, 0xc9, // 22a0 + 0x7e, 0xd0, 0xfe, 0x68, 0x48, 0xc9, 0xfc, 0xd0, // 22a8 + 0xfe, 0x28, 0xe0, 0xde, 0xd0, 0xfe, 0xc0, 0xad, // 22b0 + 0xd0, 0xfe, 0xba, 0xe0, 0xff, 0xd0, 0xfe, 0xad, // 22b8 + 0x02, 0x02, 0xc9, 0x12, 0xd0, 0xfe, 0xa9, 0x13, // 22c0 + 0x8d, 0x02, 0x02, 0xa2, 0x42, 0xa0, 0x00, 0xa5, // 22c8 + 0x3a, 0x85, 0x0c, 0xa5, 0x3b, 0x85, 0x0d, 0xa9, // 22d0 + 0x00, 0x48, 0xb9, 0x53, 0x02, 0x28, 0x32, 0x0c, // 22d8 + 0x08, 0xd9, 0x5b, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 22e0 + 0x30, 0xd9, 0x5f, 0x02, 0xd0, 0xfe, 0xe6, 0x0c, // 22e8 + 0xc8, 0xc0, 0x04, 0xd0, 0xe2, 0x88, 0xc6, 0x0c, // 22f0 + 0xa9, 0xff, 0x48, 0xb9, 0x53, 0x02, 0x28, 0x32, // 22f8 + 0x0c, 0x08, 0xd9, 0x5b, 0x02, 0xd0, 0xfe, 0x68, // 2300 + 0x49, 0x7d, 0xd9, 0x5f, 0x02, 0xd0, 0xfe, 0xc6, // 2308 + 0x0c, 0x88, 0x10, 0xe4, 0xa0, 0x00, 0xa5, 0x42, // 2310 + 0x85, 0x0c, 0xa5, 0x43, 0x85, 0x0d, 0xa9, 0x00, // 2318 + 0x48, 0xb9, 0x57, 0x02, 0x28, 0x52, 0x0c, 0x08, // 2320 + 0xd9, 0x5b, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, // 2328 + 0xd9, 0x5f, 0x02, 0xd0, 0xfe, 0xe6, 0x0c, 0xc8, // 2330 + 0xc0, 0x04, 0xd0, 0xe2, 0x88, 0xc6, 0x0c, 0xa9, // 2338 + 0xff, 0x48, 0xb9, 0x57, 0x02, 0x28, 0x52, 0x0c, // 2340 + 0x08, 0xd9, 0x5b, 0x02, 0xd0, 0xfe, 0x68, 0x49, // 2348 + 0x7d, 0xd9, 0x5f, 0x02, 0xd0, 0xfe, 0xc6, 0x0c, // 2350 + 0x88, 0x10, 0xe4, 0xa0, 0x00, 0xa5, 0x4a, 0x85, // 2358 + 0x0c, 0xa5, 0x4b, 0x85, 0x0d, 0xa9, 0x00, 0x48, // 2360 + 0xb9, 0x4f, 0x02, 0x28, 0x12, 0x0c, 0x08, 0xd9, // 2368 + 0x5b, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x30, 0xd9, // 2370 + 0x5f, 0x02, 0xd0, 0xfe, 0xe6, 0x0c, 0xc8, 0xc0, // 2378 + 0x04, 0xd0, 0xe2, 0x88, 0xc6, 0x0c, 0xa9, 0xff, // 2380 + 0x48, 0xb9, 0x4f, 0x02, 0x28, 0x12, 0x0c, 0x08, // 2388 + 0xd9, 0x5b, 0x02, 0xd0, 0xfe, 0x68, 0x49, 0x7d, // 2390 + 0xd9, 0x5f, 0x02, 0xd0, 0xfe, 0xc6, 0x0c, 0x88, // 2398 + 0x10, 0xe4, 0xe0, 0x42, 0xd0, 0xfe, 0xba, 0xe0, // 23a0 + 0xff, 0xd0, 0xfe, 0xad, 0x02, 0x02, 0xc9, 0x13, // 23a8 + 0xd0, 0xfe, 0xa9, 0x14, 0x8d, 0x02, 0x02, 0x58, // 23b0 + 0xd8, 0xa2, 0x0e, 0xa0, 0xff, 0xa9, 0x00, 0x85, // 23b8 + 0x0c, 0x85, 0x0d, 0x85, 0x0e, 0x8d, 0x05, 0x02, // 23c0 + 0x85, 0x0f, 0x85, 0x10, 0xa9, 0xff, 0x85, 0x12, // 23c8 + 0x8d, 0x06, 0x02, 0xa9, 0x02, 0x85, 0x11, 0x18, // 23d0 + 0x20, 0x4e, 0x26, 0xe6, 0x0c, 0xe6, 0x0f, 0x08, // 23d8 + 0x08, 0x68, 0x29, 0x82, 0x28, 0xd0, 0x02, 0xe6, // 23e0 + 0x10, 0x05, 0x10, 0x85, 0x11, 0x38, 0x20, 0x4e, // 23e8 + 0x26, 0xc6, 0x0c, 0xe6, 0x0d, 0xd0, 0xe0, 0xa9, // 23f0 + 0x00, 0x85, 0x10, 0xee, 0x05, 0x02, 0xe6, 0x0e, // 23f8 + 0x08, 0x68, 0x29, 0x82, 0x85, 0x11, 0xc6, 0x12, // 2400 + 0xce, 0x06, 0x02, 0xa5, 0x0e, 0x85, 0x0f, 0xd0, // 2408 + 0xc6, 0xe0, 0x0e, 0xd0, 0xfe, 0xc0, 0xff, 0xd0, // 2410 + 0xfe, 0xba, 0xe0, 0xff, 0xd0, 0xfe, 0xad, 0x02, // 2418 + 0x02, 0xc9, 0x14, 0xd0, 0xfe, 0xa9, 0x15, 0x8d, // 2420 + 0x02, 0x02, 0xf8, 0xa2, 0x0e, 0xa0, 0xff, 0xa9, // 2428 + 0x99, 0x85, 0x0d, 0x85, 0x0e, 0x8d, 0x05, 0x02, // 2430 + 0x85, 0x0f, 0xa9, 0x01, 0x85, 0x0c, 0x85, 0x10, // 2438 + 0xa9, 0x81, 0x85, 0x11, 0xa9, 0x00, 0x85, 0x12, // 2440 + 0x8d, 0x06, 0x02, 0x38, 0x20, 0xf7, 0x24, 0xc6, // 2448 + 0x0c, 0xa5, 0x0f, 0xd0, 0x08, 0xc6, 0x10, 0xa9, // 2450 + 0x99, 0x85, 0x0f, 0xd0, 0x12, 0x29, 0x0f, 0xd0, // 2458 + 0x0c, 0xc6, 0x0f, 0xc6, 0x0f, 0xc6, 0x0f, 0xc6, // 2460 + 0x0f, 0xc6, 0x0f, 0xc6, 0x0f, 0xc6, 0x0f, 0x08, // 2468 + 0x68, 0x29, 0x82, 0x05, 0x10, 0x85, 0x11, 0x18, // 2470 + 0x20, 0xf7, 0x24, 0xe6, 0x0c, 0xa5, 0x0d, 0xf0, // 2478 + 0x15, 0x29, 0x0f, 0xd0, 0x0c, 0xc6, 0x0d, 0xc6, // 2480 + 0x0d, 0xc6, 0x0d, 0xc6, 0x0d, 0xc6, 0x0d, 0xc6, // 2488 + 0x0d, 0xc6, 0x0d, 0x4c, 0x4b, 0x24, 0xa9, 0x99, // 2490 + 0x85, 0x0d, 0xa5, 0x0e, 0xf0, 0x39, 0x29, 0x0f, // 2498 + 0xd0, 0x18, 0xc6, 0x0e, 0xc6, 0x0e, 0xc6, 0x0e, // 24a0 + 0xc6, 0x0e, 0xc6, 0x0e, 0xc6, 0x0e, 0xe6, 0x12, // 24a8 + 0xe6, 0x12, 0xe6, 0x12, 0xe6, 0x12, 0xe6, 0x12, // 24b0 + 0xe6, 0x12, 0xc6, 0x0e, 0xe6, 0x12, 0xa5, 0x12, // 24b8 + 0x8d, 0x06, 0x02, 0xa5, 0x0e, 0x8d, 0x05, 0x02, // 24c0 + 0x85, 0x0f, 0x08, 0x68, 0x29, 0x82, 0x09, 0x01, // 24c8 + 0x85, 0x11, 0xe6, 0x10, 0x4c, 0x4b, 0x24, 0xe0, // 24d0 + 0x0e, 0xd0, 0xfe, 0xc0, 0xff, 0xd0, 0xfe, 0xba, // 24d8 + 0xe0, 0xff, 0xd0, 0xfe, 0xd8, 0xad, 0x02, 0x02, // 24e0 + 0xc9, 0x15, 0xd0, 0xfe, 0xa9, 0xf0, 0x8d, 0x02, // 24e8 + 0x02, 0x4c, 0xf1, 0x24, 0x4c, 0x00, 0x04, 0x08, // 24f0 + 0xa5, 0x0d, 0x65, 0x0e, 0x08, 0xc5, 0x0f, 0xd0, // 24f8 + 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, 0xd0, 0xfe, // 2500 + 0x28, 0x08, 0xa5, 0x0d, 0xe5, 0x12, 0x08, 0xc5, // 2508 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, // 2510 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0x6d, 0x05, // 2518 + 0x02, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, // 2520 + 0x83, 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, // 2528 + 0x0d, 0xed, 0x06, 0x02, 0x08, 0xc5, 0x0f, 0xd0, // 2530 + 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, 0xd0, 0xfe, // 2538 + 0x28, 0x08, 0xa5, 0x0e, 0x8d, 0x0b, 0x02, 0xa5, // 2540 + 0x0d, 0x20, 0x0a, 0x02, 0x08, 0xc5, 0x0f, 0xd0, // 2548 + 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, 0xd0, 0xfe, // 2550 + 0x28, 0x08, 0xa5, 0x12, 0x8d, 0x0e, 0x02, 0xa5, // 2558 + 0x0d, 0x20, 0x0d, 0x02, 0x08, 0xc5, 0x0f, 0xd0, // 2560 + 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, 0xd0, 0xfe, // 2568 + 0x28, 0x08, 0xa5, 0x0d, 0x75, 0x00, 0x08, 0xc5, // 2570 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, // 2578 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0xf5, 0x04, // 2580 + 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x83, // 2588 + 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, // 2590 + 0x7d, 0xf7, 0x01, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, // 2598 + 0x68, 0x29, 0x83, 0xc5, 0x11, 0xd0, 0xfe, 0x28, // 25a0 + 0x08, 0xa5, 0x0d, 0xfd, 0xf8, 0x01, 0x08, 0xc5, // 25a8 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, // 25b0 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0x79, 0x06, // 25b8 + 0x01, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, // 25c0 + 0x83, 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, // 25c8 + 0x0d, 0xf9, 0x07, 0x01, 0x08, 0xc5, 0x0f, 0xd0, // 25d0 + 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, 0xd0, 0xfe, // 25d8 + 0x28, 0x08, 0xa5, 0x0d, 0x61, 0x44, 0x08, 0xc5, // 25e0 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, // 25e8 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0xe1, 0x46, // 25f0 + 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x83, // 25f8 + 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, // 2600 + 0x71, 0x56, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, // 2608 + 0x29, 0x83, 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x08, // 2610 + 0xa5, 0x0d, 0xf1, 0x58, 0x08, 0xc5, 0x0f, 0xd0, // 2618 + 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, 0xd0, 0xfe, // 2620 + 0x28, 0x08, 0xa5, 0x0d, 0x72, 0x52, 0x08, 0xc5, // 2628 + 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x83, 0xc5, 0x11, // 2630 + 0xd0, 0xfe, 0x28, 0x08, 0xa5, 0x0d, 0xf2, 0x54, // 2638 + 0x08, 0xc5, 0x0f, 0xd0, 0xfe, 0x68, 0x29, 0x83, // 2640 + 0xc5, 0x11, 0xd0, 0xfe, 0x28, 0x60, 0xa5, 0x11, // 2648 + 0x29, 0x83, 0x48, 0xa5, 0x0d, 0x45, 0x0e, 0x30, // 2650 + 0x0a, 0xa5, 0x0d, 0x45, 0x0f, 0x10, 0x04, 0x68, // 2658 + 0x09, 0x40, 0x48, 0x68, 0x85, 0x11, 0x08, 0xa5, // 2660 + 0x0d, 0x72, 0x52, 0x08, 0xc5, 0x0f, 0xd0, 0xfe, // 2668 + 0x68, 0x29, 0xc3, 0xc5, 0x11, 0xd0, 0xfe, 0x28, // 2670 + 0x08, 0xa5, 0x0d, 0xf2, 0x54, 0x08, 0xc5, 0x0f, // 2678 + 0xd0, 0xfe, 0x68, 0x29, 0xc3, 0xc5, 0x11, 0xd0, // 2680 + 0xfe, 0x28, 0x60, 0x91, 0x26, 0x82, 0x16, 0x88, // 2688 + 0x88, 0x08, 0x88, 0x88, 0x88, 0x28, 0xb0, 0xfe, // 2690 + 0x70, 0xfe, 0x30, 0xfe, 0xf0, 0xfe, 0xc9, 0x49, // 2698 + 0xd0, 0xfe, 0xe0, 0x4e, 0xd0, 0xfe, 0xc0, 0x41, // 26a0 + 0xd0, 0xfe, 0x48, 0x8a, 0x48, 0xba, 0xe0, 0xfd, // 26a8 + 0xd0, 0xfe, 0x68, 0xaa, 0xa9, 0xff, 0x48, 0x28, // 26b0 + 0x68, 0xe8, 0x49, 0xaa, 0x6c, 0xff, 0x02, 0xea, // 26b8 + 0xea, 0x4c, 0xc1, 0x26, 0x4c, 0x00, 0x04, 0x0e, // 26c0 + 0x27, 0x0e, 0x27, 0xd5, 0x26, 0xce, 0x16, 0x0e, // 26c8 + 0x27, 0x0e, 0x27, 0x88, 0x88, 0x08, 0x88, 0x88, // 26d0 + 0x88, 0x28, 0xb0, 0xfe, 0x70, 0xfe, 0x30, 0xfe, // 26d8 + 0xf0, 0xfe, 0xc9, 0x58, 0xd0, 0xfe, 0xe0, 0x04, // 26e0 + 0xd0, 0xfe, 0xc0, 0x46, 0xd0, 0xfe, 0x48, 0x8a, // 26e8 + 0x48, 0xba, 0xe0, 0xfd, 0xd0, 0xfe, 0x68, 0xaa, // 26f0 + 0xa9, 0xff, 0x48, 0x28, 0x68, 0xe8, 0xe8, 0x49, // 26f8 + 0xaa, 0x7c, 0xf9, 0x02, 0xea, 0xea, 0x4c, 0x06, // 2700 + 0x27, 0x4c, 0x00, 0x04, 0xea, 0xea, 0xea, 0xea, // 2708 + 0x4c, 0x10, 0x27, 0x4c, 0x00, 0x04, 0x4c, 0x16, // 2710 + 0x27, 0x4c, 0x00, 0x04, 0x4c, 0x1c, 0x27, 0x4c, // 2718 + 0x00, 0x04, 0x88, 0x88, 0x08, 0x88, 0x88, 0x88, // 2720 + 0xc9, 0xbd, 0xf0, 0x42, 0xc9, 0x42, 0xd0, 0xfe, // 2728 + 0xe0, 0x52, 0xd0, 0xfe, 0xc0, 0x48, 0xd0, 0xfe, // 2730 + 0x85, 0x0a, 0x86, 0x0b, 0xba, 0xbd, 0x02, 0x01, // 2738 + 0xc9, 0x30, 0xd0, 0xfe, 0x68, 0xc9, 0x34, 0xd0, // 2740 + 0xfe, 0xba, 0xe0, 0xfc, 0xd0, 0xfe, 0xad, 0xff, // 2748 + 0x01, 0xc9, 0x17, 0xd0, 0xfe, 0xad, 0xfe, 0x01, // 2750 + 0xc9, 0x20, 0xd0, 0xfe, 0xa9, 0xff, 0x48, 0xa6, // 2758 + 0x0b, 0xe8, 0xa5, 0x0a, 0x49, 0xaa, 0x28, 0x40, // 2760 + 0x4c, 0x68, 0x27, 0x4c, 0x00, 0x04, 0xe0, 0xad, // 2768 + 0xd0, 0xfe, 0xc0, 0xb1, 0xd0, 0xfe, 0x85, 0x0a, // 2770 + 0x86, 0x0b, 0xba, 0xbd, 0x02, 0x01, 0xc9, 0xff, // 2778 + 0xd0, 0xfe, 0x68, 0xc9, 0xf7, 0xd0, 0xfe, 0xba, // 2780 + 0xe0, 0xfc, 0xd0, 0xfe, 0xad, 0xff, 0x01, 0xc9, // 2788 + 0x17, 0xd0, 0xfe, 0xad, 0xfe, 0x01, 0xc9, 0x46, // 2790 + 0xd0, 0xfe, 0xa9, 0x04, 0x48, 0xa6, 0x0b, 0xe8, // 2798 + 0xa5, 0x0a, 0x49, 0xaa, 0x28, 0x40, 0x4c, 0xa6, // 27a0 + 0x27, 0x4c, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, // 27a8 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 27b0 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 27b8 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 27c0 + 0x00, 0x00, 0x00, 0x00, 0xea, 0xea, 0xea, 0xea, // 27c8 + 0x4c, 0xd0, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, // 27d0 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 27d8 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 27e0 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 27e8 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 27f0 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 27f8 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2800 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2808 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2810 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2818 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2820 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2828 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2830 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2838 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2840 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2848 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2850 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2858 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2860 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2868 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2870 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2878 + 0xea, 0xea, 0xea, 0xea, 0x4c, 0x84, 0x28, 0xff, // 2880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 28f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 29f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 2ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 30f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 31f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 32f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 33f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 34f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 35f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 36f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 37f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 38f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 39f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 3ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 40f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 41f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 42f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 43f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 44f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 45f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 46f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 47f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 48f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 49f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 4ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 50f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 51f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 52f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 53f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 54f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 55f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 56f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 57f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 58f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 59f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 5ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 60f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 61f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 62f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 63f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 64f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 65f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 66f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 67f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 68f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 69f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 6ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 70f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 71f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 72f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 73f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 74f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 75f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 76f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 77f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 78f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 79f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 7ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 80f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 81f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 82f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 83f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 84f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 85f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 86f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 87f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 88f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 89f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 8ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 90f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 91f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 92f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 93f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 94f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 95f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 96f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 97f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 98f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 99f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9a98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9aa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9aa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9af0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9af8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9b98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9be0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9be8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9bf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9c98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9cf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9d98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9da0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9da8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9db0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9db8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9dc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9dc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9dd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9dd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9de0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9de8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9df0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9df8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9e98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9eb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9eb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9f98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9fe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // 9ff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // a9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aa98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aaa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aaa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aaf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aaf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ab98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // abf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ac98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ace0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ace8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // acf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ad98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ada0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ada8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // add0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // add8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ade0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ade8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // adf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ae98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aeb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aeb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // af98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // afe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // aff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // b9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ba98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // baa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // baa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // baf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // baf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bb98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bbf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bc98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bcf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bd98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bde0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bde8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bdf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // be98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // beb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // beb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bf98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bfe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // bff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // c9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ca98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // caa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // caa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // caf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // caf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cb98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cbf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cc98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ccf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cd98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cde0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cde8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cdf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ce98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ceb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ceb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ced0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ced8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cf98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cfe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // cff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // d9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // da98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // daa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // daa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // daf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // daf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // db98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dbf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dc98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dcf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dd98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dde0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dde8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ddf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // de98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // deb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // deb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ded0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ded8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // def0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // def8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // df98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dfe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // dff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // e9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ea98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eaa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eaa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ead0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ead8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eaf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eaf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eb98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ebf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ec98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ece0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ece8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ecf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ed98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ede0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ede8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // edf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ee98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eeb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eeb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ef98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // efe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eff0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // eff8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f000 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f008 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f010 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f018 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f020 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f028 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f030 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f038 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f040 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f048 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f050 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f058 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f060 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f068 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f070 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f078 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f080 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f088 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f090 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f098 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f0f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f100 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f108 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f110 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f118 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f120 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f128 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f130 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f138 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f140 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f148 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f150 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f158 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f160 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f168 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f170 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f178 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f180 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f188 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f190 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f198 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f1f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f200 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f208 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f210 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f218 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f220 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f228 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f230 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f238 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f240 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f248 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f250 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f258 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f260 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f268 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f270 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f278 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f280 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f288 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f290 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f298 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f2f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f300 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f308 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f310 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f318 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f320 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f328 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f330 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f338 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f340 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f348 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f350 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f358 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f360 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f368 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f370 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f378 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f380 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f388 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f390 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f398 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f3f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f400 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f408 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f410 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f418 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f420 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f428 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f430 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f438 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f440 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f448 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f450 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f458 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f460 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f468 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f470 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f478 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f480 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f488 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f490 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f498 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f4f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f500 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f508 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f510 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f518 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f520 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f528 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f530 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f538 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f540 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f548 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f550 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f558 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f560 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f568 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f570 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f578 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f580 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f588 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f590 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f598 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f5f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f600 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f608 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f610 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f618 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f620 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f628 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f630 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f638 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f640 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f648 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f650 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f658 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f660 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f668 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f670 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f678 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f680 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f688 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f690 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f698 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f6f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f700 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f708 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f710 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f718 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f720 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f728 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f730 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f738 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f740 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f748 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f750 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f758 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f760 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f768 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f770 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f778 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f780 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f788 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f790 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f798 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f7f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f800 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f808 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f810 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f818 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f820 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f828 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f830 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f838 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f840 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f848 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f850 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f858 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f860 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f868 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f870 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f878 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f880 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f888 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f890 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f898 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f8f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f900 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f908 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f910 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f918 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f920 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f928 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f930 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f938 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f940 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f948 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f950 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f958 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f960 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f968 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f970 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f978 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f980 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f988 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f990 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f998 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9a0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9a8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9b0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9b8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9c0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9c8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9d0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9d8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9e0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9e8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9f0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // f9f8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fa98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // faa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // faa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fab0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fab8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fac0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fac8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fad0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fad8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fae0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fae8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // faf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // faf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fb98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fba0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fba8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fbf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fc98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fca0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fca8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fce0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fce8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fcf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fd98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fda0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fda8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fde0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fde8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdf0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fdf8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fe98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fea0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fea8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // feb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // feb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fec0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fec8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fed0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fed8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fee0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fee8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fef0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fef8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff00 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff08 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff10 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff18 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff20 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff28 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff30 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff38 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff40 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff48 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff50 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff58 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff60 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff68 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff70 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff78 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff80 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff88 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff90 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ff98 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffa0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffa8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffb0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffb8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffc0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffc8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffd0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffd8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffe0 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ffe8 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // fff0 + 0xff, 0xff, 0x16, 0x27, 0x1c, 0x27, 0x24, 0x27, // fff8 +]; + +export default function Test65C02ROM() { + let mem = [...MEMORY]; + return { + start: function() { + return 0x00; + }, + end: function() { + return 0xff; + }, + read: function(page, off) { + return mem[(page - 0x00) << 8 | off]; + }, + write: function(page, off, val) { + mem[(page - 0x00) << 8 | off] = val; + }, + reset: function() { + mem = [...MEMORY]; + }, + }; +} diff --git a/test/tscpu6502.spec.js b/test/tscpu6502.spec.js new file mode 100644 index 00000000..70ae1981 --- /dev/null +++ b/test/tscpu6502.spec.js @@ -0,0 +1,2240 @@ +import CPU6502 from './perf/impl/tscpu6502'; + +function assertByte(b) { + expect(b <= 0xFF).toEqual(true); + expect(b >= 0x00).toEqual(true); +} + +function Memory(size) { + var data = Buffer.alloc(size << 8); + + return { + start: function() { + return 0; + }, + + end: function() { + return size - 1; + }, + + read: function(page, off) { + assertByte(page); + assertByte(off); + + return data[(page << 8) | off]; + }, + + write: function(page, off, val) { + assertByte(page); + assertByte(off); + assertByte(val); + + data[(page << 8) | off] = val; + }, + + reset: function() { + } + }; +} + +function Program(page, code) { + var data = Buffer.from(code); + + return { + start: function() { + return page; + }, + + end: function() { + return page; + }, + + read: function(page, off) { + assertByte(page); + assertByte(off); + return data[off]; + } + }; +} + +var bios = new Program(0xff, [ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x0D, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x04, 0x00, 0xff +]); + +var FLAGS = { + N: 0x80, // Negative + V: 0x40, // oVerflow + DEFAULT: 0x20, // Default + B: 0x10, // Break + D: 0x08, // Decimal + I: 0x04, // Interrupt + Z: 0x02, // Zero + C: 0x01 // Carry +}; + +var DEFAULT_STATE = { + cycles: 0, + s: FLAGS.DEFAULT, + sp: 0xff, + a: 0x00, + x: 0x00, + y: 0x00, + pc: 0x0400 +}; + +var memory; +var cpu; +var program; + +function initState(initialState) { + var state = Object.assign({}, DEFAULT_STATE, initialState); + cpu.setState(state); +} + +function expectState(initialState, expectedState) { + var state = Object.assign({}, initialState, expectedState); + expect(cpu.getState()).toEqual(state); +} + +function initMemory(memAry) { + for (var idx = 0; idx < memAry.length; idx++) { + var mem = memAry[idx]; + var page = mem[0]; + var off = mem[1]; + var data = mem[2]; + for (var jdx = 0; jdx < data.length; jdx++) { + cpu.write(page, off++, data[jdx]); + if (off > 0xff) { + page++; + off = 0; + } + } + } +} + +function expectMemory(expectAry) { + var memAry = []; + for (var idx = 0; idx < expectAry.length; idx++) { + var mem = expectAry[idx]; + var page = mem[0]; + var off = mem[1]; + var expectData = mem[2]; + var data = []; + for (var jdx = 0; jdx < expectData.length; jdx++) { + data.push(cpu.read(page, off++)); + if (off > 0xff) { + page++; + off = 0; + } + } + memAry.push([mem[0], mem[1], data]); + } + expect(memAry).toEqual(expectAry); +} + +function expectStack(expectAry) { + var state = cpu.getState(); + expectMemory([[0x01, state.sp + 1, expectAry]]); +} + +function testCode(code, steps, setupState, expectedState) { + var initialState = Object.assign({}, DEFAULT_STATE, setupState); + var finalState = Object.assign({ + pc: initialState.pc + code.length + }, expectedState); + + program = new Program(0x04, code); + cpu.addPageHandler(program); + + cpu.setState(initialState); + cpu.stepDebug(steps); + expectState(initialState, finalState); +} + +describe('CPU6502', function() { + beforeEach(function() { + cpu = new CPU6502(); + memory = new Memory(4); + + cpu.addPageHandler(memory); + cpu.addPageHandler(bios); + }); + + describe('#signals', function () { + it('should reset', function () { + cpu.reset(); + + expectState(DEFAULT_STATE, { + cycles: 2 + }); + }); + + it('should irq', function () { + cpu.irq(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should not irq if I set', function () { + initState({ + s: FLAGS.DEFAULT | FLAGS.I + }); + + cpu.irq(); + + expectState(DEFAULT_STATE, { + s: FLAGS.DEFAULT | FLAGS.I, + pc: 0x400 + }); + }); + + it('should nmi', function () { + cpu.nmi(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + }); + + describe('#misc', function () { + it('should NOP', function () { + testCode([0xEA], 1, {}, { + cycles: 2 + }); + }); + + it('should BRK', function () { + testCode([0x00, 0x00], 1, {}, { + cycles: 7, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should RTI', function () { + initMemory([[0x01, 0xFD, [0xA0, 0x34, 0x12]]]); + testCode([0x40], 1, { + sp: 0xFC + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N, + sp: 0xFF, + pc: 0x1234 + }); + }); + }); + + describe('#registers', function() { + it('should LDA immediate', function () { + testCode([0xA9, 0x44], 1, {}, { + cycles: 2, + a: 0x44 + }); + }); + + it('should TAX', function () { + testCode([0xAA], 1, { + a: 0x44 + }, { + cycles: 2, + x: 0x44 + }); + }); + + it('should TAY', function () { + testCode([0xA8], 1, { + a: 0x44 + }, { + cycles: 2, + y: 0x44 + }); + }); + + it('should LDX immediate', function () { + testCode([0xA2, 0x44], 1, {}, { + cycles: 2, + x: 0x44 + }); + }); + + it('should TXA', function () { + testCode([0x8A], 1, { + x: 0x44 + }, { + cycles: 2, + a: 0x44 + }); + }); + + it('should DEX', function () { + testCode([0xCA], 1, { + x: 0x44 + }, { + cycles: 2, + x: 0x43 + }); + }); + + it('should INX', function () { + testCode([0xE8], 1, { + x: 0x44 + }, { + cycles: 2, + x: 0x45 + }); + }); + + it('should LDY immediate', function () { + testCode([0xA0, 0x44], 1, {}, { + cycles: 2, + y: 0x44 + }); + }); + + it('should TYA', function () { + testCode([0x98], 1, { + y: 0x44 + }, { + cycles: 2, + a: 0x44 + }); + }); + + it('should DEY', function () { + testCode([0x88], 1, { + y: 0x44 + }, { + cycles: 2, + y: 0x43 + }); + }); + + it('should INY', function () { + testCode([0xC8], 1, { + y: 0x44 + }, { + cycles: 2, + y: 0x45 + }); + }); + }); + + describe('#flags', function() { + it('should SEC', function () { + testCode([0x38], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should CLC', function () { + testCode([0x18], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should SEI', function () { + testCode([0x78], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.I + }); + }); + + it('should CLI', function () { + testCode([0x58], 1, { + s: FLAGS.DEFAULT | FLAGS.I + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should CLV', function () { + testCode([0xB8], 1, { + s: FLAGS.DEFAULT | FLAGS.V + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should SED', function () { + testCode([0xF8], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.D + }); + }); + + it('should CLD', function () { + testCode([0xD8], 1, { + s: FLAGS.DEFAULT | FLAGS.D + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + }); + + describe('#stack', function() { + it('should TXS', function() { + testCode([0x9A], 1, { + x: 0x44 + }, { + cycles: 2, + sp: 0x44 + }); + }); + + it('should TSX', function() { + testCode([0xBA], 1, { + sp: 0x44 + }, { + cycles: 2, + x: 0x44 + }); + }); + + it('should PHA', function() { + testCode([0x48], 1, { + a: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLA', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0x68], 1, { + sp: 0xfe + }, { + cycles: 4, + a: 0x44, + sp: 0xff + }); + }); + + it('should PHP', function() { + testCode([0x08], 1, { + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.C + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([FLAGS.DEFAULT | FLAGS.B | FLAGS.N | FLAGS.C]); + }); + + it('should PLP', function() { + initMemory([[0x01, 0xff, [FLAGS.N | FLAGS.C]]]); + testCode([0x28], 1, { + sp: 0xfe + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.C, + sp: 0xff + }); + }); + }); + + describe('#jumps', function() { + it('should JMP abs', function () { + testCode([0x4C, 0x34, 0x12], 1, {}, { + cycles: 3, + pc: 0x1234 + }); + }); + + it('should JMP (abs)', function () { + initMemory([[0x03, 0x33, [0x34, 0x12]]]); + testCode([0x6C, 0x33, 0x03], 1, {}, { + cycles: 5, + pc: 0x1234 + }); + }); + + it('should JMP (abs) across page boundries with bugs', function () { + initMemory([[0x02, 0xFF, [0x34, 0x12]], + [0x02, 0x00, [0xff]]]); + testCode([0x6C, 0xFF, 0x02], 1, {}, { + cycles: 5, + pc: 0xFF34 + }); + }); + + it('should JSR abs', function () { + testCode([0x20, 0x34, 0x12], 1, {}, { + cycles: 6, + sp: 0xFD, + pc: 0x1234 + }); + expectStack([0x02, 0x04]); + }); + + it('should RTS', function () { + initMemory([[0x01, 0xFE, [0x34, 0x12]]]); + testCode([0x60], 1, { + sp: 0xFD + }, { + cycles: 6, + sp: 0xFF, + pc: 0x1235 + }); + }); + }); + + describe('#branches', function() { + // ********** bcs + it('should BCS forward', function () { + testCode([0xB0, 0x7F], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BCS backward', function () { + testCode([0xB0, 0xff], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 3, + pc: 0x0401 + }); + }); + + it('should BCS across pages with an extra cycle', function () { + testCode([0xB0, 0xfd], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 4, + pc: 0x03FF + }); + }); + + it('should not BCS if carry clear', function () { + testCode([0xB0, 0xfd], 1, {}, { + cycles: 2, + pc: 0x0402 + }); + }); + + it('should BCC forward', function () { + testCode([0x90, 0x7F], 1, {}, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BCC backward', function () { + testCode([0x90, 0xff], 1, {}, { + cycles: 3, + pc: 0x0401 + }); + }); + + it('should BCC across pages with an extra cycle', function () { + testCode([0x90, 0xfd], 1, {}, { + cycles: 4, + pc: 0x03FF + }); + }); + + it('should not BCC if carry set', function () { + testCode([0x90, 0xfd], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + pc: 0x0402 + }); + }); + }); + + describe('#read memory', function() { + // ********** zp + it('should LDY zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA4, 0x33], 1, {}, { + cycles: 3, + y: 0x44 + }); + }); + + it('should LDA zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA5, 0x33], 1, {}, { + cycles: 3, + a: 0x44 + }); + }); + + it('should LDX zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA6, 0x33], 1, {}, { + cycles: 3, + x: 0x44 + }); + }); + + // ********** zp,x + it('should LDY zp,x', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB4, 0x33], 1, { + x: 3 + }, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA zp,x', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB5, 0x33], 1, { + x: 3 + }, { + cycles: 4, + a: 0x44 + }); + }); + + // ********** zp,y + it('should LDX zp,y', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB6, 0x33], 1, { + y: 3 + }, { + cycles: 4, + x: 0x44 + }); + }); + + // ********** (zp,x) + it('should LDA (zp,x)', function () { + initMemory([ + [0x00, 0x36, [0x33, 0x03]], + [0x03, 0x33, [0x44]]] + ); + testCode([0xA1, 0x33], 1, { + x: 3 + }, { + cycles: 6, + a: 0x44 + }); + }); + + // ********** (zp),y + it('should LDA (zp),y', function () { + initMemory([ + [0x00, 0x33, [0x33, 0x03]], + [0x03, 0x36, [0x44]] + ]); + testCode([0xB1, 0x33], 1, { + y: 3 + }, { + cycles: 5, + a: 0x44 + }); + }); + + // ********** (zp),y + it('should LDA (zp),y with an extra cycle on page cross', function () { + initMemory([ + [0x00, 0x33, [0x33, 0x02]], + [0x03, 0x32, [0x44]] + ]); + testCode([0xB1, 0x33], 1, { + y: 0xff + }, { + cycles: 6, + a: 0x44 + }); + }); + + // ********** abs + it('should LDY abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAC, 0x33, 0x03], 1, {}, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAD, 0x33, 0x03], 1, {}, { + cycles: 4, + a: 0x44 + }); + }); + + it('should LDX abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAE, 0x33, 0x03], 1, {}, { + cycles: 4, + x: 0x44 + }); + }); + + // ********** abs, x + it('should LDY abs,x', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBC, 0x33, 0x03], 1, { + x: 3 + }, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA abs,x', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBD, 0x33, 0x03], 1, { + x: 3 + }, { + cycles: 4, + a: 0x44 + }); + }); + + it('should LDY abs,x with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBC, 0x33, 0x02], 1, { + x: 0xff + }, { + cycles: 5, + y: 0x44 + }); + }); + + it('should LDA abs,x with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBD, 0x33, 0x02], 1, { + x: 0xff + }, { + cycles: 5, + a: 0x44 + }); + }); + + // ********** abs, y + it('should LDX abs,y', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBE, 0x33, 0x03], 1, { + y: 3 + }, { + cycles: 4, + x: 0x44 + }); + }); + + it('should LDX abs,y with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBE, 0x33, 0x02], 1, { + y: 0xff + }, { + cycles: 5, + x: 0x44 + }); + }); + }); + + describe('#write memory', function() { + // ********** zp + it('should STY zp', function () { + testCode([0x84, 0x33], 1, { + y: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + it('should STA zp', function () { + testCode([0x85, 0x33], 1, { + a: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + it('should STX zp', function () { + testCode([0x86, 0x33], 1, { + x: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + // ********** zp,x + it('should STY zp,x', function () { + testCode([0x94, 0x33], 1, { + x: 3, + y: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + it('should STA zp,x', function () { + testCode([0x95, 0x33], 1, { + a: 0x44, + x: 3 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + // ********** zp,y + it('should STX zp,y', function () { + testCode([0x96, 0x33], 1, { + x: 0x44, + y: 3 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + // ********** (zp,x) + it('should STA (zp,x)', function () { + initMemory([[0x00, 0x36, [0x33, 0x03]]]); + testCode([0x81, 0x33], 1, { + a: 0x44, + x: 3 + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + // ********** (zp),y + it('should STA (zp),y', function () { + initMemory([[0x00, 0x33, [0x33, 0x03]]]); + testCode([0x91, 0x33], 1, { + a: 0x44, + y: 3 + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + // ********** abs + it('should STY abs', function () { + testCode([0x8C, 0x33, 0x03], 1, { + y: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STA abs', function () { + testCode([0x8D, 0x33, 0x03], 1, { + a: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STX abs', function () { + testCode([0x8E, 0x33, 0x03], 1, { + x: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + // ********** abs, x + it('should STA abs,x', function () { + testCode([0x9D, 0x33, 0x03], 1, { + a: 0x44, + x: 0x03 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + it('should STA abs,x with no extra cycle on page cross', function () { + testCode([0x9D, 0x33, 0x02], 1, { + a: 0x44, + x: 0xff + }, { + cycles: 5, + pc: 0x0403 + }); + expectMemory([[0x03, 0x32, [0x44]]]); + }); + + // ********** abs, y + it('should STA abs,y', function () { + testCode([0x99, 0x33, 0x03], 1, { + a: 0x44, + y: 0x03 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + it('should STA abs,y with no extra cycle on page cross', function () { + testCode([0x99, 0x33, 0x02], 1, { + a: 0x44, + y: 0xff + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x32, [0x44]]]); + }); + }); + + describe('#bit operations', function() { + // ********** ASL + it('should ASL A', function () { + testCode([0x0A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0xAA, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should ASL A with carry out', function () { + testCode([0x0A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x54, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ASL abs', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should ASL abs with carry out', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x0E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x54]]]); + }); + + // ********** ROL + it('should ROL A', function () { + testCode([0x2A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0xAA, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should ROL A with carry out', function () { + testCode([0x2A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x54, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ROL A with carry in', function () { + testCode([0x2A], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0xAA + }, { + cycles: 2, + a: 0x55, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ROL abs', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x2E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should ROL abs with carry out', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x54]]]); + }); + + it('should ROL abs with carry in', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2E, 0x33, 0x03], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + // ********** LSR + it('should LSR A', function () { + testCode([0x4A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x55 + }); + }); + + it('should LSR A with carry out', function () { + testCode([0x4A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0x2A, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should LSR abs', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x4E, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + it('should LSR abs with carry out', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x4E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x2A]]]); + }); + + // ********** ROR + it('should ROR A', function () { + testCode([0x6A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x55 + }); + }); + + it('should ROR A with carry out', function () { + testCode([0x6A], 1, { + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x2A + }); + }); + + it('should ROR A with carry in', function () { + testCode([0x6A], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C | FLAGS.N, + a: 0xAA + }); + }); + + it('should ROR abs', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x6E, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + it('should ROR abs with carry out', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x6E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x2A]]]); + }); + + it('should ROR abs with carry in', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x6E, 0x33, 0x03], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should AND', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x2D, 0x33, 0x03], 1, { + a: 0xA5 + }, { + cycles: 4, + a: 0x05 + }); + }); + + it('should ORA', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0D, 0x33, 0x03], 1, { + a: 0xA0 + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N, + a: 0xF5 + }); + }); + + it('should EOR', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x4D, 0x33, 0x03], 1, { + a: 0xA5 + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N, + a: 0xF0 + }); + }); + + it('should BIT zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x24, 0x33], 1, { + a: 0x55 + }, { + cycles: 3, + s: FLAGS.DEFAULT | FLAGS.V + }); + }); + + it('should BIT abs', function() { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2C, 0x33, 0x03], 1, { + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.Z + }); + }); + }); + + describe('#math', function() { + // ********** ADC + it('should ADC', function () { + testCode([0x69, 0x55], 1, { + a: 0x23 + }, { + cycles: 2, + a: 0x78, + s: FLAGS.DEFAULT + }); + }); + + it('should ADC with carry in', function () { + testCode([0x69, 0x55], 1, { + a: 0x23, + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + a: 0x79, + s: FLAGS.DEFAULT + }); + }); + + it('should ADC with overflow out', function () { + testCode([0x69, 0x55], 1, { + a: 0x2B + }, { + cycles: 2, + a: 0x80, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.V + }); + }); + + it('should ADC with carry out', function () { + testCode([0x69, 0x55], 1, { + a: 0xBB + }, { + cycles: 2, + a: 0x10, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** ADC BCD + it('should ADC BCD', function () { + testCode([0x69, 0x16], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x25 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.V, + a: 0x41 + }); + }); + + it('should ADC BCD with carry in', function () { + testCode([0x69, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + s: FLAGS.DEFAULT| FLAGS.D | FLAGS.V, + a: 0x79 + }); + }); + + it('should ADC BCD with carry out', function () { + testCode([0x69, 0x10], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x91 + }, { + cycles: 2, + a: 0x01, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + // ********** SBC + it('should SBC', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + a: 0x32, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should SBC with borrow in', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT, + a: 0x55 + }, { + cycles: 2, + a: 0x31, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should SBC with borrow out', function () { + testCode([0xE9, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + a: 0xCE, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should SBC with overflow out', function () { + testCode([0xE9, 0x7F], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0xAF + }, { + cycles: 2, + a: 0x30, + s: FLAGS.DEFAULT | FLAGS.V | FLAGS.C + }); + }); + + // ********** SBC BCD + it('should SBC BCD', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + a: 0x32, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + it('should SBC BCD with borrow in', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x55 + }, { + cycles: 2, + a: 0x31, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + it('should SBC BCD with borrow out', function () { + testCode([0xE9, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + a: 0x68, + s: FLAGS.DEFAULT | FLAGS.D + }); + }); + + // ********** INC + it('should INC zp', function() { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xE6, 0x33], 1, { + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x45]]]); + }); + + it('should INC zp,x', function() { + initMemory([[0x00, 0x043, [0x44]]]); + testCode([0xF6, 0x33], 1, { + x: 0x10 + }, { + cycles: 6 + }); + expectMemory([[0x00, 0x43, [0x45]]]); + }); + + it('should INC abs', function() { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xEE, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x45]]]); + }); + + it('should INC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xFE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x45]]]); + }); + + // ********** DEC + it('should DEC zp', function() { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xC6, 0x33], 1, { + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x43]]]); + }); + + it('should DEC zp,x', function() { + initMemory([[0x00, 0x043, [0x44]]]); + testCode([0xD6, 0x33], 1, { + x: 0x10 + }, { + cycles: 6 + }); + expectMemory([[0x00, 0x43, [0x43]]]); + }); + + it('should DEC abs', function() { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xCE, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x43]]]); + }); + + it('should DEC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xDE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x43]]]); + }); + }); + + describe('#comparison', function() { + // ********** CMP + it('should CMP less than', function() { + testCode([0xc9, 0x44], 1, { + a: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CMP equal', function() { + testCode([0xc9, 0x44], 1, { + a: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CMP greater than', function() { + testCode([0xc9, 0x44], 1, { + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** CPX + it('should CPX less than', function() { + testCode([0xE0, 0x44], 1, { + x: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CPX equal', function() { + testCode([0xE0, 0x44], 1, { + x: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CPX greater than', function() { + testCode([0xE0, 0x44], 1, { + x: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** CPY + it('should CPY less than', function() { + testCode([0xE0, 0x44], 1, { + y: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CPY equal', function() { + testCode([0xc0, 0x44], 1, { + y: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CPY greater than', function() { + testCode([0xc0, 0x44], 1, { + y: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + }); + + describe('#utility', function() { + it('should list', function() { + var listing = cpu.list(0xff00); + expect(listing[0]).toEqual('FF00- 00 00 BRK #$00'); + }); + + it('should list with symbols', function() { + var listing = cpu.list(0xff00, {0x00: 'ZERO', 0xFF00: 'ENTRY'}); + expect(listing[0]).toEqual('FF00- ENTRY 00 00 BRK #ZERO'); + }); + + it('should dump page', function() { + var page = cpu.dumpPage(0xff); + expect(page).toContain('FF80: 48 45 4C 4C 4F 0D 00 00 00 00 00 00 00 00 00 00 HELLO...........'); + }); + + it('should dump registers', function() { + var regs = cpu.dumpRegisters(); + expect(regs).toEqual('0000- A=00 X=00 Y=00 P=20 S=FF --------'); + }); + }); +}); + +describe('65c02', function() { + beforeEach(function() { + cpu = new CPU6502({'65C02': true}); + memory = new Memory(4); + + cpu.addPageHandler(memory); + cpu.addPageHandler(bios); + }); + + describe('#signals', function() { + it('should clear D on IRQ', function() { + initState({ + s: FLAGS.DEFAULT | FLAGS.D + }); + + cpu.irq(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should clear D on NMI', function() { + initState({ + s: FLAGS.DEFAULT | FLAGS.D + }); + + cpu.nmi(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should clear D on BRK', function () { + testCode([0x00, 0x00], 1, { + s: FLAGS.DEFAULT | FLAGS.D + }, { + cycles: 7, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + }); + + describe('#stack', function() { + it('should PHX', function() { + testCode([0xDA], 1, { + x: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLX', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0xFA], 1, { + sp: 0xfe + }, { + cycles: 4, + x: 0x44, + sp: 0xff + }); + }); + + it('should PHY', function() { + testCode([0x5A], 1, { + y: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLY', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0x7A], 1, { + sp: 0xfe + }, { + cycles: 4, + y: 0x44, + sp: 0xff + }); + }); + + }); + + describe('#jumps', function() { + it('should JMP (abs)', function () { + initMemory([[0x03, 0x33, [0x34, 0x12]]]); + testCode([0x6C, 0x33, 0x03], 1, {}, { + cycles: 6, + pc: 0x1234 + }); + }); + + it('should JMP (abs) across page boundries without bugs', function () { + initMemory([[0x02, 0xFF, [0x34, 0x12]], + [0x02, 0x00, [0xff]]]); + testCode([0x6C, 0xFF, 0x02], 1, {}, { + cycles: 6, + pc: 0x1234 + }); + }); + + it('should JMP (abs, x)', function () { + initMemory([[0x03, 0x43, [0x34, 0x12]]]); + testCode([0x7C, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 6, + pc: 0x1234 + }); + }); + }); + + describe('#other addressing mode fixes', function () { + it('should INC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xFE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x45]]]); + }); + }); + + describe('#branches', function() { + it('should BRA forward', function () { + testCode([0x80, 0x7F], 1, {}, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BRA backward', function () { + testCode([0x80, 0xFF], 1, {}, { + cycles: 3, + pc: 0x0401 + }); + }); + }); + + describe('#read memory', function() { + // ********** (zp) + it('should LDA (zp)', function () { + initMemory([[0x00, 0x33, [0x33,0x03]], + [0x03, 0x33, [0x44]]]); + testCode([0xB2, 0x33], 1, {}, { + cycles: 5, + a: 0x44 + }); + }); + }); + + describe('#write memory', function() { + // ********** (zp) + it('should STA (zp)', function () { + initMemory([[0x00, 0x33, [0x33, 0x03]]]); + testCode([0x92, 0x33], 1, { + a: 0x44 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STZ abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0x9C, 0x33, 0x03], 1, { + a: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x00]]]); + }); + }); + + describe('#logical operators', function() { + it('should BIT imm and effect other flags', function() { + testCode([0x89, 0x33], 1, { + s: FLAGS.DEFAULT | FLAGS.N, + a: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.N + }); + }); + + it('should BIT imm', function() { + testCode([0x89, 0x33], 1, { + a: 0x03 + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + // ******** TRB + it('should TRB zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x14, 0x33], 1, { + a: 0xA5 + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x50]]]); + }); + + it('should TRB abs', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x1C, 0x33, 0x03], 1, { + a: 0xAA + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.Z + }); + expectMemory([[0x00, 0x33, [0x00]]]); + }); + + // ******** TSB + it('should TSB zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x04, 0x33], 1, { + a: 0xA5 + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0xF5]]]); + }); + + it('should TSB abs', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0C, 0x33, 0x03], 1, { + a: 0xAA + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.Z + }); + expectMemory([[0x03, 0x33, [0xFF]]]); + }); + }); + + describe('Branch bit set/reset', function () { + // ******** BBR + it('BBR0 should branch if bit 0 clear', function() { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x0F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR0 should branch backward', function () { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x0F, 0x33, 0xFF], 1, {}, { + cycles: 6, + pc: 0x0402 + }); + }); + + it('BBR1 should branch if bit 1 clear', function() { + initMemory([[0x00, 0x33, [0xFD]]]); + testCode([0x1F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR2 should branch if bit 2 clear', function() { + initMemory([[0x00, 0x33, [0xFB]]]); + testCode([0x2F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR3 should branch if bit 3 clear', function() { + initMemory([[0x00, 0x33, [0xF7]]]); + testCode([0x3F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR4 should branch if bit 4 clear', function() { + initMemory([[0x00, 0x33, [0xEF]]]); + testCode([0x4F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR5 should branch if bit 5 clear', function() { + initMemory([[0x00, 0x33, [0xDF]]]); + testCode([0x5F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR6 should branch if bit 6 clear', function() { + initMemory([[0x00, 0x33, [0xBF]]]); + testCode([0x6F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR7 should branch if bit 7 clear', function() { + initMemory([[0x00, 0x33, [0x7F]]]); + testCode([0x7F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR0 should not branch if bit 0 set', function() { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x0F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR1 should not branch if bit 1 set', function() { + initMemory([[0x00, 0x33, [0x02]]]); + testCode([0x1F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR2 should not branch if bit 2 set', function() { + initMemory([[0x00, 0x33, [0x04]]]); + testCode([0x2F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR3 should not branch if bit 3 set', function() { + initMemory([[0x00, 0x33, [0x08]]]); + testCode([0x3F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR4 should not branch if bit 4 set', function() { + initMemory([[0x00, 0x33, [0x10]]]); + testCode([0x4F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR5 should not branch if bit 5 set', function() { + initMemory([[0x00, 0x33, [0x20]]]); + testCode([0x5F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR6 should not branch if bit 6 set', function() { + initMemory([[0x00, 0x33, [0x40]]]); + testCode([0x6F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR7 should not branch if bit 7 set', function() { + initMemory([[0x00, 0x33, [0x80]]]); + testCode([0x7F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + // ******** BBS + it('BBS0 should branch if bit 0 set', function() { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x8F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS0 should branch backward', function () { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x8F, 0x33, 0xFF], 1, {}, { + cycles: 6, + pc: 0x0402 + }); + }); + + it('BBS1 should branch if bit 1 set', function() { + initMemory([[0x00, 0x33, [0x02]]]); + testCode([0x9F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS2 should branch if bit 2 set', function() { + initMemory([[0x00, 0x33, [0x04]]]); + testCode([0xAF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS3 should branch if bit 3 set', function() { + initMemory([[0x00, 0x33, [0x08]]]); + testCode([0xBF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS4 should branch if bit 4 set', function() { + initMemory([[0x00, 0x33, [0x10]]]); + testCode([0xCF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS5 should branch if bit 5 set', function() { + initMemory([[0x00, 0x33, [0x20]]]); + testCode([0xDF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS6 should branch if bit 6 set', function() { + initMemory([[0x00, 0x33, [0x40]]]); + testCode([0xEF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS7 should branch if bit 7 set', function() { + initMemory([[0x00, 0x33, [0x80]]]); + testCode([0xFF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS0 should not branch if bit 0 clear', function() { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x8F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS1 should not branch if bit 1 clear', function() { + initMemory([[0x00, 0x33, [0xFD]]]); + testCode([0x9F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS2 should not branch if bit 2 clear', function() { + initMemory([[0x00, 0x33, [0xFB]]]); + testCode([0xAF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS3 should not branch if bit 3 clear', function() { + initMemory([[0x00, 0x33, [0xF7]]]); + testCode([0xBF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS4 should not branch if bit 4 clear', function() { + initMemory([[0x00, 0x33, [0xEF]]]); + testCode([0xCF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS5 should not branch if bit 5 clear', function() { + initMemory([[0x00, 0x33, [0xDF]]]); + testCode([0xDF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS6 should not branch if bit 6 clear', function() { + initMemory([[0x00, 0x33, [0xBF]]]); + testCode([0xEF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS7 should not branch if bit 7 clear', function() { + initMemory([[0x00, 0x33, [0x7B]]]); + testCode([0xFF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + }); + + describe('Bit set/reset', function () { + it('RMB0 should reset bit 0', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x07, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFE]]]); + }); + + it('RMB1 should reset bit 1', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x17, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFD]]]); + }); + + it('RMB2 should reset bit 2', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x27, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFB]]]); + }); + + it('RMB3 should reset bit 3', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x37, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xF7]]]); + }); + + it('RMB4 should reset bit 4', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x47, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xEF]]]); + }); + + it('RMB5 should reset bit 5', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x57, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xDF]]]); + }); + + it('RMB6 should reset bit 6', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x67, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xBF]]]); + }); + + it('RMB7 should reset bit 7', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x77, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x7F]]]); + }); + + it('SMB0 should set bit 0', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0x87, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x01]]]); + }); + + it('SMB1 should set bit 1', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0x97, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x02]]]); + }); + + it('SMB2 should set bit 2', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xA7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x04]]]); + }); + + it('SMB3 should set bit 3', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xB7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x08]]]); + }); + + it('SMB4 should set bit 4', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xC7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x10]]]); + }); + + it('SMB5 should set bit 5', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xD7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x20]]]); + }); + + it('SMB6 should set bit 6', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xE7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x40]]]); + }); + + it('SMB7 should set bit 7', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xF7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x80]]]); + }); + }); + + describe('#math', function() { + // INC A + it('should INC A', function() { + testCode([0x1A], 1, { + a: 0x44 + },{ + cycles: 2, + a: 0x45 + }); + }); + + // DEC A + it('should DEC A', function() { + testCode([0x3A], 1, { + a: 0x44 + },{ + cycles: 2, + a: 0x43 + }); + }); + }); +}); diff --git a/test/tscpu6502v2.spec.js b/test/tscpu6502v2.spec.js new file mode 100644 index 00000000..bc837dd8 --- /dev/null +++ b/test/tscpu6502v2.spec.js @@ -0,0 +1,2240 @@ +import CPU6502 from './perf/impl/tscpu6502v2'; + +function assertByte(b) { + expect(b <= 0xFF).toEqual(true); + expect(b >= 0x00).toEqual(true); +} + +function Memory(size) { + var data = Buffer.alloc(size << 8); + + return { + start: function() { + return 0; + }, + + end: function() { + return size - 1; + }, + + read: function(page, off) { + assertByte(page); + assertByte(off); + + return data[(page << 8) | off]; + }, + + write: function(page, off, val) { + assertByte(page); + assertByte(off); + assertByte(val); + + data[(page << 8) | off] = val; + }, + + reset: function() { + } + }; +} + +function Program(page, code) { + var data = Buffer.from(code); + + return { + start: function() { + return page; + }, + + end: function() { + return page; + }, + + read: function(page, off) { + assertByte(page); + assertByte(off); + return data[off]; + } + }; +} + +var bios = new Program(0xff, [ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x0D, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x04, 0x00, 0xff +]); + +var FLAGS = { + N: 0x80, // Negative + V: 0x40, // oVerflow + DEFAULT: 0x20, // Default + B: 0x10, // Break + D: 0x08, // Decimal + I: 0x04, // Interrupt + Z: 0x02, // Zero + C: 0x01 // Carry +}; + +var DEFAULT_STATE = { + cycles: 0, + s: FLAGS.DEFAULT, + sp: 0xff, + a: 0x00, + x: 0x00, + y: 0x00, + pc: 0x0400 +}; + +var memory; +var cpu; +var program; + +function initState(initialState) { + var state = Object.assign({}, DEFAULT_STATE, initialState); + cpu.setState(state); +} + +function expectState(initialState, expectedState) { + var state = Object.assign({}, initialState, expectedState); + expect(cpu.getState()).toEqual(state); +} + +function initMemory(memAry) { + for (var idx = 0; idx < memAry.length; idx++) { + var mem = memAry[idx]; + var page = mem[0]; + var off = mem[1]; + var data = mem[2]; + for (var jdx = 0; jdx < data.length; jdx++) { + cpu.write(page, off++, data[jdx]); + if (off > 0xff) { + page++; + off = 0; + } + } + } +} + +function expectMemory(expectAry) { + var memAry = []; + for (var idx = 0; idx < expectAry.length; idx++) { + var mem = expectAry[idx]; + var page = mem[0]; + var off = mem[1]; + var expectData = mem[2]; + var data = []; + for (var jdx = 0; jdx < expectData.length; jdx++) { + data.push(cpu.read(page, off++)); + if (off > 0xff) { + page++; + off = 0; + } + } + memAry.push([mem[0], mem[1], data]); + } + expect(memAry).toEqual(expectAry); +} + +function expectStack(expectAry) { + var state = cpu.getState(); + expectMemory([[0x01, state.sp + 1, expectAry]]); +} + +function testCode(code, steps, setupState, expectedState) { + var initialState = Object.assign({}, DEFAULT_STATE, setupState); + var finalState = Object.assign({ + pc: initialState.pc + code.length + }, expectedState); + + program = new Program(0x04, code); + cpu.addPageHandler(program); + + cpu.setState(initialState); + cpu.stepDebug(steps); + expectState(initialState, finalState); +} + +describe('CPU6502', function() { + beforeEach(function() { + cpu = new CPU6502(); + memory = new Memory(4); + + cpu.addPageHandler(memory); + cpu.addPageHandler(bios); + }); + + describe('#signals', function () { + it('should reset', function () { + cpu.reset(); + + expectState(DEFAULT_STATE, { + cycles: 2 + }); + }); + + it('should irq', function () { + cpu.irq(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should not irq if I set', function () { + initState({ + s: FLAGS.DEFAULT | FLAGS.I + }); + + cpu.irq(); + + expectState(DEFAULT_STATE, { + s: FLAGS.DEFAULT | FLAGS.I, + pc: 0x400 + }); + }); + + it('should nmi', function () { + cpu.nmi(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + }); + + describe('#misc', function () { + it('should NOP', function () { + testCode([0xEA], 1, {}, { + cycles: 2 + }); + }); + + it('should BRK', function () { + testCode([0x00, 0x00], 1, {}, { + cycles: 7, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should RTI', function () { + initMemory([[0x01, 0xFD, [0xA0, 0x34, 0x12]]]); + testCode([0x40], 1, { + sp: 0xFC + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N, + sp: 0xFF, + pc: 0x1234 + }); + }); + }); + + describe('#registers', function() { + it('should LDA immediate', function () { + testCode([0xA9, 0x44], 1, {}, { + cycles: 2, + a: 0x44 + }); + }); + + it('should TAX', function () { + testCode([0xAA], 1, { + a: 0x44 + }, { + cycles: 2, + x: 0x44 + }); + }); + + it('should TAY', function () { + testCode([0xA8], 1, { + a: 0x44 + }, { + cycles: 2, + y: 0x44 + }); + }); + + it('should LDX immediate', function () { + testCode([0xA2, 0x44], 1, {}, { + cycles: 2, + x: 0x44 + }); + }); + + it('should TXA', function () { + testCode([0x8A], 1, { + x: 0x44 + }, { + cycles: 2, + a: 0x44 + }); + }); + + it('should DEX', function () { + testCode([0xCA], 1, { + x: 0x44 + }, { + cycles: 2, + x: 0x43 + }); + }); + + it('should INX', function () { + testCode([0xE8], 1, { + x: 0x44 + }, { + cycles: 2, + x: 0x45 + }); + }); + + it('should LDY immediate', function () { + testCode([0xA0, 0x44], 1, {}, { + cycles: 2, + y: 0x44 + }); + }); + + it('should TYA', function () { + testCode([0x98], 1, { + y: 0x44 + }, { + cycles: 2, + a: 0x44 + }); + }); + + it('should DEY', function () { + testCode([0x88], 1, { + y: 0x44 + }, { + cycles: 2, + y: 0x43 + }); + }); + + it('should INY', function () { + testCode([0xC8], 1, { + y: 0x44 + }, { + cycles: 2, + y: 0x45 + }); + }); + }); + + describe('#flags', function() { + it('should SEC', function () { + testCode([0x38], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should CLC', function () { + testCode([0x18], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should SEI', function () { + testCode([0x78], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.I + }); + }); + + it('should CLI', function () { + testCode([0x58], 1, { + s: FLAGS.DEFAULT | FLAGS.I + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should CLV', function () { + testCode([0xB8], 1, { + s: FLAGS.DEFAULT | FLAGS.V + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should SED', function () { + testCode([0xF8], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.D + }); + }); + + it('should CLD', function () { + testCode([0xD8], 1, { + s: FLAGS.DEFAULT | FLAGS.D + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + }); + + describe('#stack', function() { + it('should TXS', function() { + testCode([0x9A], 1, { + x: 0x44 + }, { + cycles: 2, + sp: 0x44 + }); + }); + + it('should TSX', function() { + testCode([0xBA], 1, { + sp: 0x44 + }, { + cycles: 2, + x: 0x44 + }); + }); + + it('should PHA', function() { + testCode([0x48], 1, { + a: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLA', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0x68], 1, { + sp: 0xfe + }, { + cycles: 4, + a: 0x44, + sp: 0xff + }); + }); + + it('should PHP', function() { + testCode([0x08], 1, { + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.C + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([FLAGS.DEFAULT | FLAGS.B | FLAGS.N | FLAGS.C]); + }); + + it('should PLP', function() { + initMemory([[0x01, 0xff, [FLAGS.N | FLAGS.C]]]); + testCode([0x28], 1, { + sp: 0xfe + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.C, + sp: 0xff + }); + }); + }); + + describe('#jumps', function() { + it('should JMP abs', function () { + testCode([0x4C, 0x34, 0x12], 1, {}, { + cycles: 3, + pc: 0x1234 + }); + }); + + it('should JMP (abs)', function () { + initMemory([[0x03, 0x33, [0x34, 0x12]]]); + testCode([0x6C, 0x33, 0x03], 1, {}, { + cycles: 5, + pc: 0x1234 + }); + }); + + it('should JMP (abs) across page boundries with bugs', function () { + initMemory([[0x02, 0xFF, [0x34, 0x12]], + [0x02, 0x00, [0xff]]]); + testCode([0x6C, 0xFF, 0x02], 1, {}, { + cycles: 5, + pc: 0xFF34 + }); + }); + + it('should JSR abs', function () { + testCode([0x20, 0x34, 0x12], 1, {}, { + cycles: 6, + sp: 0xFD, + pc: 0x1234 + }); + expectStack([0x02, 0x04]); + }); + + it('should RTS', function () { + initMemory([[0x01, 0xFE, [0x34, 0x12]]]); + testCode([0x60], 1, { + sp: 0xFD + }, { + cycles: 6, + sp: 0xFF, + pc: 0x1235 + }); + }); + }); + + describe('#branches', function() { + // ********** bcs + it('should BCS forward', function () { + testCode([0xB0, 0x7F], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BCS backward', function () { + testCode([0xB0, 0xff], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 3, + pc: 0x0401 + }); + }); + + it('should BCS across pages with an extra cycle', function () { + testCode([0xB0, 0xfd], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 4, + pc: 0x03FF + }); + }); + + it('should not BCS if carry clear', function () { + testCode([0xB0, 0xfd], 1, {}, { + cycles: 2, + pc: 0x0402 + }); + }); + + it('should BCC forward', function () { + testCode([0x90, 0x7F], 1, {}, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BCC backward', function () { + testCode([0x90, 0xff], 1, {}, { + cycles: 3, + pc: 0x0401 + }); + }); + + it('should BCC across pages with an extra cycle', function () { + testCode([0x90, 0xfd], 1, {}, { + cycles: 4, + pc: 0x03FF + }); + }); + + it('should not BCC if carry set', function () { + testCode([0x90, 0xfd], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + pc: 0x0402 + }); + }); + }); + + describe('#read memory', function() { + // ********** zp + it('should LDY zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA4, 0x33], 1, {}, { + cycles: 3, + y: 0x44 + }); + }); + + it('should LDA zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA5, 0x33], 1, {}, { + cycles: 3, + a: 0x44 + }); + }); + + it('should LDX zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA6, 0x33], 1, {}, { + cycles: 3, + x: 0x44 + }); + }); + + // ********** zp,x + it('should LDY zp,x', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB4, 0x33], 1, { + x: 3 + }, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA zp,x', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB5, 0x33], 1, { + x: 3 + }, { + cycles: 4, + a: 0x44 + }); + }); + + // ********** zp,y + it('should LDX zp,y', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB6, 0x33], 1, { + y: 3 + }, { + cycles: 4, + x: 0x44 + }); + }); + + // ********** (zp,x) + it('should LDA (zp,x)', function () { + initMemory([ + [0x00, 0x36, [0x33, 0x03]], + [0x03, 0x33, [0x44]]] + ); + testCode([0xA1, 0x33], 1, { + x: 3 + }, { + cycles: 6, + a: 0x44 + }); + }); + + // ********** (zp),y + it('should LDA (zp),y', function () { + initMemory([ + [0x00, 0x33, [0x33, 0x03]], + [0x03, 0x36, [0x44]] + ]); + testCode([0xB1, 0x33], 1, { + y: 3 + }, { + cycles: 5, + a: 0x44 + }); + }); + + // ********** (zp),y + it('should LDA (zp),y with an extra cycle on page cross', function () { + initMemory([ + [0x00, 0x33, [0x33, 0x02]], + [0x03, 0x32, [0x44]] + ]); + testCode([0xB1, 0x33], 1, { + y: 0xff + }, { + cycles: 6, + a: 0x44 + }); + }); + + // ********** abs + it('should LDY abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAC, 0x33, 0x03], 1, {}, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAD, 0x33, 0x03], 1, {}, { + cycles: 4, + a: 0x44 + }); + }); + + it('should LDX abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAE, 0x33, 0x03], 1, {}, { + cycles: 4, + x: 0x44 + }); + }); + + // ********** abs, x + it('should LDY abs,x', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBC, 0x33, 0x03], 1, { + x: 3 + }, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA abs,x', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBD, 0x33, 0x03], 1, { + x: 3 + }, { + cycles: 4, + a: 0x44 + }); + }); + + it('should LDY abs,x with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBC, 0x33, 0x02], 1, { + x: 0xff + }, { + cycles: 5, + y: 0x44 + }); + }); + + it('should LDA abs,x with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBD, 0x33, 0x02], 1, { + x: 0xff + }, { + cycles: 5, + a: 0x44 + }); + }); + + // ********** abs, y + it('should LDX abs,y', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBE, 0x33, 0x03], 1, { + y: 3 + }, { + cycles: 4, + x: 0x44 + }); + }); + + it('should LDX abs,y with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBE, 0x33, 0x02], 1, { + y: 0xff + }, { + cycles: 5, + x: 0x44 + }); + }); + }); + + describe('#write memory', function() { + // ********** zp + it('should STY zp', function () { + testCode([0x84, 0x33], 1, { + y: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + it('should STA zp', function () { + testCode([0x85, 0x33], 1, { + a: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + it('should STX zp', function () { + testCode([0x86, 0x33], 1, { + x: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + // ********** zp,x + it('should STY zp,x', function () { + testCode([0x94, 0x33], 1, { + x: 3, + y: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + it('should STA zp,x', function () { + testCode([0x95, 0x33], 1, { + a: 0x44, + x: 3 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + // ********** zp,y + it('should STX zp,y', function () { + testCode([0x96, 0x33], 1, { + x: 0x44, + y: 3 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + // ********** (zp,x) + it('should STA (zp,x)', function () { + initMemory([[0x00, 0x36, [0x33, 0x03]]]); + testCode([0x81, 0x33], 1, { + a: 0x44, + x: 3 + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + // ********** (zp),y + it('should STA (zp),y', function () { + initMemory([[0x00, 0x33, [0x33, 0x03]]]); + testCode([0x91, 0x33], 1, { + a: 0x44, + y: 3 + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + // ********** abs + it('should STY abs', function () { + testCode([0x8C, 0x33, 0x03], 1, { + y: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STA abs', function () { + testCode([0x8D, 0x33, 0x03], 1, { + a: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STX abs', function () { + testCode([0x8E, 0x33, 0x03], 1, { + x: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + // ********** abs, x + it('should STA abs,x', function () { + testCode([0x9D, 0x33, 0x03], 1, { + a: 0x44, + x: 0x03 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + it('should STA abs,x with no extra cycle on page cross', function () { + testCode([0x9D, 0x33, 0x02], 1, { + a: 0x44, + x: 0xff + }, { + cycles: 5, + pc: 0x0403 + }); + expectMemory([[0x03, 0x32, [0x44]]]); + }); + + // ********** abs, y + it('should STA abs,y', function () { + testCode([0x99, 0x33, 0x03], 1, { + a: 0x44, + y: 0x03 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + it('should STA abs,y with no extra cycle on page cross', function () { + testCode([0x99, 0x33, 0x02], 1, { + a: 0x44, + y: 0xff + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x32, [0x44]]]); + }); + }); + + describe('#bit operations', function() { + // ********** ASL + it('should ASL A', function () { + testCode([0x0A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0xAA, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should ASL A with carry out', function () { + testCode([0x0A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x54, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ASL abs', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should ASL abs with carry out', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x0E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x54]]]); + }); + + // ********** ROL + it('should ROL A', function () { + testCode([0x2A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0xAA, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should ROL A with carry out', function () { + testCode([0x2A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x54, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ROL A with carry in', function () { + testCode([0x2A], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0xAA + }, { + cycles: 2, + a: 0x55, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ROL abs', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x2E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should ROL abs with carry out', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x54]]]); + }); + + it('should ROL abs with carry in', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2E, 0x33, 0x03], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + // ********** LSR + it('should LSR A', function () { + testCode([0x4A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x55 + }); + }); + + it('should LSR A with carry out', function () { + testCode([0x4A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0x2A, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should LSR abs', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x4E, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + it('should LSR abs with carry out', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x4E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x2A]]]); + }); + + // ********** ROR + it('should ROR A', function () { + testCode([0x6A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x55 + }); + }); + + it('should ROR A with carry out', function () { + testCode([0x6A], 1, { + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x2A + }); + }); + + it('should ROR A with carry in', function () { + testCode([0x6A], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C | FLAGS.N, + a: 0xAA + }); + }); + + it('should ROR abs', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x6E, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + it('should ROR abs with carry out', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x6E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x2A]]]); + }); + + it('should ROR abs with carry in', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x6E, 0x33, 0x03], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should AND', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x2D, 0x33, 0x03], 1, { + a: 0xA5 + }, { + cycles: 4, + a: 0x05 + }); + }); + + it('should ORA', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0D, 0x33, 0x03], 1, { + a: 0xA0 + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N, + a: 0xF5 + }); + }); + + it('should EOR', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x4D, 0x33, 0x03], 1, { + a: 0xA5 + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N, + a: 0xF0 + }); + }); + + it('should BIT zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x24, 0x33], 1, { + a: 0x55 + }, { + cycles: 3, + s: FLAGS.DEFAULT | FLAGS.V + }); + }); + + it('should BIT abs', function() { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2C, 0x33, 0x03], 1, { + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.Z + }); + }); + }); + + describe('#math', function() { + // ********** ADC + it('should ADC', function () { + testCode([0x69, 0x55], 1, { + a: 0x23 + }, { + cycles: 2, + a: 0x78, + s: FLAGS.DEFAULT + }); + }); + + it('should ADC with carry in', function () { + testCode([0x69, 0x55], 1, { + a: 0x23, + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + a: 0x79, + s: FLAGS.DEFAULT + }); + }); + + it('should ADC with overflow out', function () { + testCode([0x69, 0x55], 1, { + a: 0x2B + }, { + cycles: 2, + a: 0x80, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.V + }); + }); + + it('should ADC with carry out', function () { + testCode([0x69, 0x55], 1, { + a: 0xBB + }, { + cycles: 2, + a: 0x10, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** ADC BCD + it('should ADC BCD', function () { + testCode([0x69, 0x16], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x25 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.V, + a: 0x41 + }); + }); + + it('should ADC BCD with carry in', function () { + testCode([0x69, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + s: FLAGS.DEFAULT| FLAGS.D | FLAGS.V, + a: 0x79 + }); + }); + + it('should ADC BCD with carry out', function () { + testCode([0x69, 0x10], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x91 + }, { + cycles: 2, + a: 0x01, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + // ********** SBC + it('should SBC', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + a: 0x32, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should SBC with borrow in', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT, + a: 0x55 + }, { + cycles: 2, + a: 0x31, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should SBC with borrow out', function () { + testCode([0xE9, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + a: 0xCE, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should SBC with overflow out', function () { + testCode([0xE9, 0x7F], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0xAF + }, { + cycles: 2, + a: 0x30, + s: FLAGS.DEFAULT | FLAGS.V | FLAGS.C + }); + }); + + // ********** SBC BCD + it('should SBC BCD', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + a: 0x32, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + it('should SBC BCD with borrow in', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x55 + }, { + cycles: 2, + a: 0x31, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + it('should SBC BCD with borrow out', function () { + testCode([0xE9, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + a: 0x68, + s: FLAGS.DEFAULT | FLAGS.D + }); + }); + + // ********** INC + it('should INC zp', function() { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xE6, 0x33], 1, { + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x45]]]); + }); + + it('should INC zp,x', function() { + initMemory([[0x00, 0x043, [0x44]]]); + testCode([0xF6, 0x33], 1, { + x: 0x10 + }, { + cycles: 6 + }); + expectMemory([[0x00, 0x43, [0x45]]]); + }); + + it('should INC abs', function() { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xEE, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x45]]]); + }); + + it('should INC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xFE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x45]]]); + }); + + // ********** DEC + it('should DEC zp', function() { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xC6, 0x33], 1, { + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x43]]]); + }); + + it('should DEC zp,x', function() { + initMemory([[0x00, 0x043, [0x44]]]); + testCode([0xD6, 0x33], 1, { + x: 0x10 + }, { + cycles: 6 + }); + expectMemory([[0x00, 0x43, [0x43]]]); + }); + + it('should DEC abs', function() { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xCE, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x43]]]); + }); + + it('should DEC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xDE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x43]]]); + }); + }); + + describe('#comparison', function() { + // ********** CMP + it('should CMP less than', function() { + testCode([0xc9, 0x44], 1, { + a: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CMP equal', function() { + testCode([0xc9, 0x44], 1, { + a: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CMP greater than', function() { + testCode([0xc9, 0x44], 1, { + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** CPX + it('should CPX less than', function() { + testCode([0xE0, 0x44], 1, { + x: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CPX equal', function() { + testCode([0xE0, 0x44], 1, { + x: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CPX greater than', function() { + testCode([0xE0, 0x44], 1, { + x: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** CPY + it('should CPY less than', function() { + testCode([0xE0, 0x44], 1, { + y: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CPY equal', function() { + testCode([0xc0, 0x44], 1, { + y: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CPY greater than', function() { + testCode([0xc0, 0x44], 1, { + y: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + }); + + describe('#utility', function() { + it('should list', function() { + var listing = cpu.list(0xff00); + expect(listing[0]).toEqual('FF00- 00 00 BRK #$00'); + }); + + it('should list with symbols', function() { + var listing = cpu.list(0xff00, {0x00: 'ZERO', 0xFF00: 'ENTRY'}); + expect(listing[0]).toEqual('FF00- ENTRY 00 00 BRK #ZERO'); + }); + + it('should dump page', function() { + var page = cpu.dumpPage(0xff); + expect(page).toContain('FF80: 48 45 4C 4C 4F 0D 00 00 00 00 00 00 00 00 00 00 HELLO...........'); + }); + + it('should dump registers', function() { + var regs = cpu.dumpRegisters(); + expect(regs).toEqual('0000- A=00 X=00 Y=00 P=20 S=FF --------'); + }); + }); +}); + +describe('65c02', function() { + beforeEach(function() { + cpu = new CPU6502({'65C02': true}); + memory = new Memory(4); + + cpu.addPageHandler(memory); + cpu.addPageHandler(bios); + }); + + describe('#signals', function() { + it('should clear D on IRQ', function() { + initState({ + s: FLAGS.DEFAULT | FLAGS.D + }); + + cpu.irq(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should clear D on NMI', function() { + initState({ + s: FLAGS.DEFAULT | FLAGS.D + }); + + cpu.nmi(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should clear D on BRK', function () { + testCode([0x00, 0x00], 1, { + s: FLAGS.DEFAULT | FLAGS.D + }, { + cycles: 7, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + }); + + describe('#stack', function() { + it('should PHX', function() { + testCode([0xDA], 1, { + x: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLX', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0xFA], 1, { + sp: 0xfe + }, { + cycles: 4, + x: 0x44, + sp: 0xff + }); + }); + + it('should PHY', function() { + testCode([0x5A], 1, { + y: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLY', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0x7A], 1, { + sp: 0xfe + }, { + cycles: 4, + y: 0x44, + sp: 0xff + }); + }); + + }); + + describe('#jumps', function() { + it('should JMP (abs)', function () { + initMemory([[0x03, 0x33, [0x34, 0x12]]]); + testCode([0x6C, 0x33, 0x03], 1, {}, { + cycles: 6, + pc: 0x1234 + }); + }); + + it('should JMP (abs) across page boundries without bugs', function () { + initMemory([[0x02, 0xFF, [0x34, 0x12]], + [0x02, 0x00, [0xff]]]); + testCode([0x6C, 0xFF, 0x02], 1, {}, { + cycles: 6, + pc: 0x1234 + }); + }); + + it('should JMP (abs, x)', function () { + initMemory([[0x03, 0x43, [0x34, 0x12]]]); + testCode([0x7C, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 6, + pc: 0x1234 + }); + }); + }); + + describe('#other addressing mode fixes', function () { + it('should INC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xFE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x45]]]); + }); + }); + + describe('#branches', function() { + it('should BRA forward', function () { + testCode([0x80, 0x7F], 1, {}, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BRA backward', function () { + testCode([0x80, 0xFF], 1, {}, { + cycles: 3, + pc: 0x0401 + }); + }); + }); + + describe('#read memory', function() { + // ********** (zp) + it('should LDA (zp)', function () { + initMemory([[0x00, 0x33, [0x33,0x03]], + [0x03, 0x33, [0x44]]]); + testCode([0xB2, 0x33], 1, {}, { + cycles: 5, + a: 0x44 + }); + }); + }); + + describe('#write memory', function() { + // ********** (zp) + it('should STA (zp)', function () { + initMemory([[0x00, 0x33, [0x33, 0x03]]]); + testCode([0x92, 0x33], 1, { + a: 0x44 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STZ abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0x9C, 0x33, 0x03], 1, { + a: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x00]]]); + }); + }); + + describe('#logical operators', function() { + it('should BIT imm and effect other flags', function() { + testCode([0x89, 0x33], 1, { + s: FLAGS.DEFAULT | FLAGS.N, + a: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.N + }); + }); + + it('should BIT imm', function() { + testCode([0x89, 0x33], 1, { + a: 0x03 + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + // ******** TRB + it('should TRB zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x14, 0x33], 1, { + a: 0xA5 + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x50]]]); + }); + + it('should TRB abs', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x1C, 0x33, 0x03], 1, { + a: 0xAA + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.Z + }); + expectMemory([[0x00, 0x33, [0x00]]]); + }); + + // ******** TSB + it('should TSB zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x04, 0x33], 1, { + a: 0xA5 + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0xF5]]]); + }); + + it('should TSB abs', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0C, 0x33, 0x03], 1, { + a: 0xAA + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.Z + }); + expectMemory([[0x03, 0x33, [0xFF]]]); + }); + }); + + describe('Branch bit set/reset', function () { + // ******** BBR + it('BBR0 should branch if bit 0 clear', function() { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x0F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR0 should branch backward', function () { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x0F, 0x33, 0xFF], 1, {}, { + cycles: 6, + pc: 0x0402 + }); + }); + + it('BBR1 should branch if bit 1 clear', function() { + initMemory([[0x00, 0x33, [0xFD]]]); + testCode([0x1F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR2 should branch if bit 2 clear', function() { + initMemory([[0x00, 0x33, [0xFB]]]); + testCode([0x2F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR3 should branch if bit 3 clear', function() { + initMemory([[0x00, 0x33, [0xF7]]]); + testCode([0x3F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR4 should branch if bit 4 clear', function() { + initMemory([[0x00, 0x33, [0xEF]]]); + testCode([0x4F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR5 should branch if bit 5 clear', function() { + initMemory([[0x00, 0x33, [0xDF]]]); + testCode([0x5F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR6 should branch if bit 6 clear', function() { + initMemory([[0x00, 0x33, [0xBF]]]); + testCode([0x6F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR7 should branch if bit 7 clear', function() { + initMemory([[0x00, 0x33, [0x7F]]]); + testCode([0x7F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR0 should not branch if bit 0 set', function() { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x0F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR1 should not branch if bit 1 set', function() { + initMemory([[0x00, 0x33, [0x02]]]); + testCode([0x1F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR2 should not branch if bit 2 set', function() { + initMemory([[0x00, 0x33, [0x04]]]); + testCode([0x2F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR3 should not branch if bit 3 set', function() { + initMemory([[0x00, 0x33, [0x08]]]); + testCode([0x3F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR4 should not branch if bit 4 set', function() { + initMemory([[0x00, 0x33, [0x10]]]); + testCode([0x4F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR5 should not branch if bit 5 set', function() { + initMemory([[0x00, 0x33, [0x20]]]); + testCode([0x5F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR6 should not branch if bit 6 set', function() { + initMemory([[0x00, 0x33, [0x40]]]); + testCode([0x6F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR7 should not branch if bit 7 set', function() { + initMemory([[0x00, 0x33, [0x80]]]); + testCode([0x7F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + // ******** BBS + it('BBS0 should branch if bit 0 set', function() { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x8F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS0 should branch backward', function () { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x8F, 0x33, 0xFF], 1, {}, { + cycles: 6, + pc: 0x0402 + }); + }); + + it('BBS1 should branch if bit 1 set', function() { + initMemory([[0x00, 0x33, [0x02]]]); + testCode([0x9F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS2 should branch if bit 2 set', function() { + initMemory([[0x00, 0x33, [0x04]]]); + testCode([0xAF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS3 should branch if bit 3 set', function() { + initMemory([[0x00, 0x33, [0x08]]]); + testCode([0xBF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS4 should branch if bit 4 set', function() { + initMemory([[0x00, 0x33, [0x10]]]); + testCode([0xCF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS5 should branch if bit 5 set', function() { + initMemory([[0x00, 0x33, [0x20]]]); + testCode([0xDF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS6 should branch if bit 6 set', function() { + initMemory([[0x00, 0x33, [0x40]]]); + testCode([0xEF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS7 should branch if bit 7 set', function() { + initMemory([[0x00, 0x33, [0x80]]]); + testCode([0xFF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS0 should not branch if bit 0 clear', function() { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x8F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS1 should not branch if bit 1 clear', function() { + initMemory([[0x00, 0x33, [0xFD]]]); + testCode([0x9F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS2 should not branch if bit 2 clear', function() { + initMemory([[0x00, 0x33, [0xFB]]]); + testCode([0xAF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS3 should not branch if bit 3 clear', function() { + initMemory([[0x00, 0x33, [0xF7]]]); + testCode([0xBF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS4 should not branch if bit 4 clear', function() { + initMemory([[0x00, 0x33, [0xEF]]]); + testCode([0xCF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS5 should not branch if bit 5 clear', function() { + initMemory([[0x00, 0x33, [0xDF]]]); + testCode([0xDF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS6 should not branch if bit 6 clear', function() { + initMemory([[0x00, 0x33, [0xBF]]]); + testCode([0xEF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS7 should not branch if bit 7 clear', function() { + initMemory([[0x00, 0x33, [0x7B]]]); + testCode([0xFF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + }); + + describe('Bit set/reset', function () { + it('RMB0 should reset bit 0', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x07, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFE]]]); + }); + + it('RMB1 should reset bit 1', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x17, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFD]]]); + }); + + it('RMB2 should reset bit 2', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x27, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFB]]]); + }); + + it('RMB3 should reset bit 3', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x37, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xF7]]]); + }); + + it('RMB4 should reset bit 4', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x47, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xEF]]]); + }); + + it('RMB5 should reset bit 5', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x57, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xDF]]]); + }); + + it('RMB6 should reset bit 6', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x67, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xBF]]]); + }); + + it('RMB7 should reset bit 7', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x77, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x7F]]]); + }); + + it('SMB0 should set bit 0', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0x87, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x01]]]); + }); + + it('SMB1 should set bit 1', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0x97, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x02]]]); + }); + + it('SMB2 should set bit 2', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xA7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x04]]]); + }); + + it('SMB3 should set bit 3', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xB7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x08]]]); + }); + + it('SMB4 should set bit 4', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xC7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x10]]]); + }); + + it('SMB5 should set bit 5', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xD7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x20]]]); + }); + + it('SMB6 should set bit 6', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xE7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x40]]]); + }); + + it('SMB7 should set bit 7', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xF7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x80]]]); + }); + }); + + describe('#math', function() { + // INC A + it('should INC A', function() { + testCode([0x1A], 1, { + a: 0x44 + },{ + cycles: 2, + a: 0x45 + }); + }); + + // DEC A + it('should DEC A', function() { + testCode([0x3A], 1, { + a: 0x44 + },{ + cycles: 2, + a: 0x43 + }); + }); + }); +}); diff --git a/test/tscpu6502v5.spec.js b/test/tscpu6502v5.spec.js new file mode 100644 index 00000000..1ca8ad6c --- /dev/null +++ b/test/tscpu6502v5.spec.js @@ -0,0 +1,2240 @@ +import CPU6502 from './perf/impl/tscpu6502v5'; + +function assertByte(b) { + expect(b <= 0xFF).toEqual(true); + expect(b >= 0x00).toEqual(true); +} + +function Memory(size) { + var data = Buffer.alloc(size << 8); + + return { + start: function() { + return 0; + }, + + end: function() { + return size - 1; + }, + + read: function(page, off) { + assertByte(page); + assertByte(off); + + return data[(page << 8) | off]; + }, + + write: function(page, off, val) { + assertByte(page); + assertByte(off); + assertByte(val); + + data[(page << 8) | off] = val; + }, + + reset: function() { + } + }; +} + +function Program(page, code) { + var data = Buffer.from(code); + + return { + start: function() { + return page; + }, + + end: function() { + return page; + }, + + read: function(page, off) { + assertByte(page); + assertByte(off); + return data[off]; + } + }; +} + +var bios = new Program(0xff, [ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x0D, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x04, 0x00, 0xff +]); + +var FLAGS = { + N: 0x80, // Negative + V: 0x40, // oVerflow + DEFAULT: 0x20, // Default + B: 0x10, // Break + D: 0x08, // Decimal + I: 0x04, // Interrupt + Z: 0x02, // Zero + C: 0x01 // Carry +}; + +var DEFAULT_STATE = { + cycles: 0, + s: FLAGS.DEFAULT, + sp: 0xff, + a: 0x00, + x: 0x00, + y: 0x00, + pc: 0x0400 +}; + +var memory; +var cpu; +var program; + +function initState(initialState) { + var state = Object.assign({}, DEFAULT_STATE, initialState); + cpu.setState(state); +} + +function expectState(initialState, expectedState) { + var state = Object.assign({}, initialState, expectedState); + expect(cpu.getState()).toEqual(state); +} + +function initMemory(memAry) { + for (var idx = 0; idx < memAry.length; idx++) { + var mem = memAry[idx]; + var page = mem[0]; + var off = mem[1]; + var data = mem[2]; + for (var jdx = 0; jdx < data.length; jdx++) { + cpu.write(page, off++, data[jdx]); + if (off > 0xff) { + page++; + off = 0; + } + } + } +} + +function expectMemory(expectAry) { + var memAry = []; + for (var idx = 0; idx < expectAry.length; idx++) { + var mem = expectAry[idx]; + var page = mem[0]; + var off = mem[1]; + var expectData = mem[2]; + var data = []; + for (var jdx = 0; jdx < expectData.length; jdx++) { + data.push(cpu.read(page, off++)); + if (off > 0xff) { + page++; + off = 0; + } + } + memAry.push([mem[0], mem[1], data]); + } + expect(memAry).toEqual(expectAry); +} + +function expectStack(expectAry) { + var state = cpu.getState(); + expectMemory([[0x01, state.sp + 1, expectAry]]); +} + +function testCode(code, steps, setupState, expectedState) { + var initialState = Object.assign({}, DEFAULT_STATE, setupState); + var finalState = Object.assign({ + pc: initialState.pc + code.length + }, expectedState); + + program = new Program(0x04, code); + cpu.addPageHandler(program); + + cpu.setState(initialState); + cpu.stepDebug(steps); + expectState(initialState, finalState); +} + +describe('CPU6502', function() { + beforeEach(function() { + cpu = new CPU6502(); + memory = new Memory(4); + + cpu.addPageHandler(memory); + cpu.addPageHandler(bios); + }); + + describe('#signals', function () { + it('should reset', function () { + cpu.reset(); + + expectState(DEFAULT_STATE, { + cycles: 2 + }); + }); + + it('should irq', function () { + cpu.irq(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should not irq if I set', function () { + initState({ + s: FLAGS.DEFAULT | FLAGS.I + }); + + cpu.irq(); + + expectState(DEFAULT_STATE, { + s: FLAGS.DEFAULT | FLAGS.I, + pc: 0x400 + }); + }); + + it('should nmi', function () { + cpu.nmi(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + }); + + describe('#misc', function () { + it('should NOP', function () { + testCode([0xEA], 1, {}, { + cycles: 2 + }); + }); + + it('should BRK', function () { + testCode([0x00, 0x00], 1, {}, { + cycles: 7, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should RTI', function () { + initMemory([[0x01, 0xFD, [0xA0, 0x34, 0x12]]]); + testCode([0x40], 1, { + sp: 0xFC + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N, + sp: 0xFF, + pc: 0x1234 + }); + }); + }); + + describe('#registers', function() { + it('should LDA immediate', function () { + testCode([0xA9, 0x44], 1, {}, { + cycles: 2, + a: 0x44 + }); + }); + + it('should TAX', function () { + testCode([0xAA], 1, { + a: 0x44 + }, { + cycles: 2, + x: 0x44 + }); + }); + + it('should TAY', function () { + testCode([0xA8], 1, { + a: 0x44 + }, { + cycles: 2, + y: 0x44 + }); + }); + + it('should LDX immediate', function () { + testCode([0xA2, 0x44], 1, {}, { + cycles: 2, + x: 0x44 + }); + }); + + it('should TXA', function () { + testCode([0x8A], 1, { + x: 0x44 + }, { + cycles: 2, + a: 0x44 + }); + }); + + it('should DEX', function () { + testCode([0xCA], 1, { + x: 0x44 + }, { + cycles: 2, + x: 0x43 + }); + }); + + it('should INX', function () { + testCode([0xE8], 1, { + x: 0x44 + }, { + cycles: 2, + x: 0x45 + }); + }); + + it('should LDY immediate', function () { + testCode([0xA0, 0x44], 1, {}, { + cycles: 2, + y: 0x44 + }); + }); + + it('should TYA', function () { + testCode([0x98], 1, { + y: 0x44 + }, { + cycles: 2, + a: 0x44 + }); + }); + + it('should DEY', function () { + testCode([0x88], 1, { + y: 0x44 + }, { + cycles: 2, + y: 0x43 + }); + }); + + it('should INY', function () { + testCode([0xC8], 1, { + y: 0x44 + }, { + cycles: 2, + y: 0x45 + }); + }); + }); + + describe('#flags', function() { + it('should SEC', function () { + testCode([0x38], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should CLC', function () { + testCode([0x18], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should SEI', function () { + testCode([0x78], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.I + }); + }); + + it('should CLI', function () { + testCode([0x58], 1, { + s: FLAGS.DEFAULT | FLAGS.I + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should CLV', function () { + testCode([0xB8], 1, { + s: FLAGS.DEFAULT | FLAGS.V + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + it('should SED', function () { + testCode([0xF8], 1, {}, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.D + }); + }); + + it('should CLD', function () { + testCode([0xD8], 1, { + s: FLAGS.DEFAULT | FLAGS.D + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + }); + + describe('#stack', function() { + it('should TXS', function() { + testCode([0x9A], 1, { + x: 0x44 + }, { + cycles: 2, + sp: 0x44 + }); + }); + + it('should TSX', function() { + testCode([0xBA], 1, { + sp: 0x44 + }, { + cycles: 2, + x: 0x44 + }); + }); + + it('should PHA', function() { + testCode([0x48], 1, { + a: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLA', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0x68], 1, { + sp: 0xfe + }, { + cycles: 4, + a: 0x44, + sp: 0xff + }); + }); + + it('should PHP', function() { + testCode([0x08], 1, { + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.C + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([FLAGS.DEFAULT | FLAGS.B | FLAGS.N | FLAGS.C]); + }); + + it('should PLP', function() { + initMemory([[0x01, 0xff, [FLAGS.N | FLAGS.C]]]); + testCode([0x28], 1, { + sp: 0xfe + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.C, + sp: 0xff + }); + }); + }); + + describe('#jumps', function() { + it('should JMP abs', function () { + testCode([0x4C, 0x34, 0x12], 1, {}, { + cycles: 3, + pc: 0x1234 + }); + }); + + it('should JMP (abs)', function () { + initMemory([[0x03, 0x33, [0x34, 0x12]]]); + testCode([0x6C, 0x33, 0x03], 1, {}, { + cycles: 5, + pc: 0x1234 + }); + }); + + it('should JMP (abs) across page boundries with bugs', function () { + initMemory([[0x02, 0xFF, [0x34, 0x12]], + [0x02, 0x00, [0xff]]]); + testCode([0x6C, 0xFF, 0x02], 1, {}, { + cycles: 5, + pc: 0xFF34 + }); + }); + + it('should JSR abs', function () { + testCode([0x20, 0x34, 0x12], 1, {}, { + cycles: 6, + sp: 0xFD, + pc: 0x1234 + }); + expectStack([0x02, 0x04]); + }); + + it('should RTS', function () { + initMemory([[0x01, 0xFE, [0x34, 0x12]]]); + testCode([0x60], 1, { + sp: 0xFD + }, { + cycles: 6, + sp: 0xFF, + pc: 0x1235 + }); + }); + }); + + describe('#branches', function() { + // ********** bcs + it('should BCS forward', function () { + testCode([0xB0, 0x7F], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BCS backward', function () { + testCode([0xB0, 0xff], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 3, + pc: 0x0401 + }); + }); + + it('should BCS across pages with an extra cycle', function () { + testCode([0xB0, 0xfd], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 4, + pc: 0x03FF + }); + }); + + it('should not BCS if carry clear', function () { + testCode([0xB0, 0xfd], 1, {}, { + cycles: 2, + pc: 0x0402 + }); + }); + + it('should BCC forward', function () { + testCode([0x90, 0x7F], 1, {}, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BCC backward', function () { + testCode([0x90, 0xff], 1, {}, { + cycles: 3, + pc: 0x0401 + }); + }); + + it('should BCC across pages with an extra cycle', function () { + testCode([0x90, 0xfd], 1, {}, { + cycles: 4, + pc: 0x03FF + }); + }); + + it('should not BCC if carry set', function () { + testCode([0x90, 0xfd], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + pc: 0x0402 + }); + }); + }); + + describe('#read memory', function() { + // ********** zp + it('should LDY zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA4, 0x33], 1, {}, { + cycles: 3, + y: 0x44 + }); + }); + + it('should LDA zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA5, 0x33], 1, {}, { + cycles: 3, + a: 0x44 + }); + }); + + it('should LDX zp', function () { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xA6, 0x33], 1, {}, { + cycles: 3, + x: 0x44 + }); + }); + + // ********** zp,x + it('should LDY zp,x', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB4, 0x33], 1, { + x: 3 + }, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA zp,x', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB5, 0x33], 1, { + x: 3 + }, { + cycles: 4, + a: 0x44 + }); + }); + + // ********** zp,y + it('should LDX zp,y', function () { + initMemory([[0x00, 0x36, [0x44]]]); + testCode([0xB6, 0x33], 1, { + y: 3 + }, { + cycles: 4, + x: 0x44 + }); + }); + + // ********** (zp,x) + it('should LDA (zp,x)', function () { + initMemory([ + [0x00, 0x36, [0x33, 0x03]], + [0x03, 0x33, [0x44]]] + ); + testCode([0xA1, 0x33], 1, { + x: 3 + }, { + cycles: 6, + a: 0x44 + }); + }); + + // ********** (zp),y + it('should LDA (zp),y', function () { + initMemory([ + [0x00, 0x33, [0x33, 0x03]], + [0x03, 0x36, [0x44]] + ]); + testCode([0xB1, 0x33], 1, { + y: 3 + }, { + cycles: 5, + a: 0x44 + }); + }); + + // ********** (zp),y + it('should LDA (zp),y with an extra cycle on page cross', function () { + initMemory([ + [0x00, 0x33, [0x33, 0x02]], + [0x03, 0x32, [0x44]] + ]); + testCode([0xB1, 0x33], 1, { + y: 0xff + }, { + cycles: 6, + a: 0x44 + }); + }); + + // ********** abs + it('should LDY abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAC, 0x33, 0x03], 1, {}, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAD, 0x33, 0x03], 1, {}, { + cycles: 4, + a: 0x44 + }); + }); + + it('should LDX abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xAE, 0x33, 0x03], 1, {}, { + cycles: 4, + x: 0x44 + }); + }); + + // ********** abs, x + it('should LDY abs,x', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBC, 0x33, 0x03], 1, { + x: 3 + }, { + cycles: 4, + y: 0x44 + }); + }); + + it('should LDA abs,x', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBD, 0x33, 0x03], 1, { + x: 3 + }, { + cycles: 4, + a: 0x44 + }); + }); + + it('should LDY abs,x with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBC, 0x33, 0x02], 1, { + x: 0xff + }, { + cycles: 5, + y: 0x44 + }); + }); + + it('should LDA abs,x with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBD, 0x33, 0x02], 1, { + x: 0xff + }, { + cycles: 5, + a: 0x44 + }); + }); + + // ********** abs, y + it('should LDX abs,y', function () { + initMemory([[0x03, 0x36, [0x44]]]); + testCode([0xBE, 0x33, 0x03], 1, { + y: 3 + }, { + cycles: 4, + x: 0x44 + }); + }); + + it('should LDX abs,y with extra cycle on page cross', function () { + initMemory([[0x03, 0x32, [0x44]]]); + testCode([0xBE, 0x33, 0x02], 1, { + y: 0xff + }, { + cycles: 5, + x: 0x44 + }); + }); + }); + + describe('#write memory', function() { + // ********** zp + it('should STY zp', function () { + testCode([0x84, 0x33], 1, { + y: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + it('should STA zp', function () { + testCode([0x85, 0x33], 1, { + a: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + it('should STX zp', function () { + testCode([0x86, 0x33], 1, { + x: 0x44 + }, { + cycles: 3 + }); + expectMemory([[0x00, 0x33, [0x44]]]); + }); + + // ********** zp,x + it('should STY zp,x', function () { + testCode([0x94, 0x33], 1, { + x: 3, + y: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + it('should STA zp,x', function () { + testCode([0x95, 0x33], 1, { + a: 0x44, + x: 3 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + // ********** zp,y + it('should STX zp,y', function () { + testCode([0x96, 0x33], 1, { + x: 0x44, + y: 3 + }, { + cycles: 4 + }); + expectMemory([[0x00, 0x36, [0x44]]]); + }); + + // ********** (zp,x) + it('should STA (zp,x)', function () { + initMemory([[0x00, 0x36, [0x33, 0x03]]]); + testCode([0x81, 0x33], 1, { + a: 0x44, + x: 3 + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + // ********** (zp),y + it('should STA (zp),y', function () { + initMemory([[0x00, 0x33, [0x33, 0x03]]]); + testCode([0x91, 0x33], 1, { + a: 0x44, + y: 3 + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + // ********** abs + it('should STY abs', function () { + testCode([0x8C, 0x33, 0x03], 1, { + y: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STA abs', function () { + testCode([0x8D, 0x33, 0x03], 1, { + a: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STX abs', function () { + testCode([0x8E, 0x33, 0x03], 1, { + x: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + // ********** abs, x + it('should STA abs,x', function () { + testCode([0x9D, 0x33, 0x03], 1, { + a: 0x44, + x: 0x03 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + it('should STA abs,x with no extra cycle on page cross', function () { + testCode([0x9D, 0x33, 0x02], 1, { + a: 0x44, + x: 0xff + }, { + cycles: 5, + pc: 0x0403 + }); + expectMemory([[0x03, 0x32, [0x44]]]); + }); + + // ********** abs, y + it('should STA abs,y', function () { + testCode([0x99, 0x33, 0x03], 1, { + a: 0x44, + y: 0x03 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x36, [0x44]]]); + }); + + it('should STA abs,y with no extra cycle on page cross', function () { + testCode([0x99, 0x33, 0x02], 1, { + a: 0x44, + y: 0xff + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x32, [0x44]]]); + }); + }); + + describe('#bit operations', function() { + // ********** ASL + it('should ASL A', function () { + testCode([0x0A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0xAA, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should ASL A with carry out', function () { + testCode([0x0A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x54, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ASL abs', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should ASL abs with carry out', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x0E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x54]]]); + }); + + // ********** ROL + it('should ROL A', function () { + testCode([0x2A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0xAA, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should ROL A with carry out', function () { + testCode([0x2A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x54, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ROL A with carry in', function () { + testCode([0x2A], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0xAA + }, { + cycles: 2, + a: 0x55, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should ROL abs', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x2E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should ROL abs with carry out', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x54]]]); + }); + + it('should ROL abs with carry in', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2E, 0x33, 0x03], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + // ********** LSR + it('should LSR A', function () { + testCode([0x4A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x55 + }); + }); + + it('should LSR A with carry out', function () { + testCode([0x4A], 1, { + a: 0x55 + }, { + cycles: 2, + a: 0x2A, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should LSR abs', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x4E, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + it('should LSR abs with carry out', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x4E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x2A]]]); + }); + + // ********** ROR + it('should ROR A', function () { + testCode([0x6A], 1, { + a: 0xAA + }, { + cycles: 2, + a: 0x55 + }); + }); + + it('should ROR A with carry out', function () { + testCode([0x6A], 1, { + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x2A + }); + }); + + it('should ROR A with carry in', function () { + testCode([0x6A], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C | FLAGS.N, + a: 0xAA + }); + }); + + it('should ROR abs', function () { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x6E, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x55]]]); + }); + + it('should ROR abs with carry out', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x6E, 0x33, 0x03], 1, { + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C + }); + expectMemory([[0x03, 0x33, [0x2A]]]); + }); + + it('should ROR abs with carry in', function () { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x6E, 0x33, 0x03], 1, { + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.C | FLAGS.N + }); + expectMemory([[0x03, 0x33, [0xAA]]]); + }); + + it('should AND', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x2D, 0x33, 0x03], 1, { + a: 0xA5 + }, { + cycles: 4, + a: 0x05 + }); + }); + + it('should ORA', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0D, 0x33, 0x03], 1, { + a: 0xA0 + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N, + a: 0xF5 + }); + }); + + it('should EOR', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x4D, 0x33, 0x03], 1, { + a: 0xA5 + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N, + a: 0xF0 + }); + }); + + it('should BIT zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x24, 0x33], 1, { + a: 0x55 + }, { + cycles: 3, + s: FLAGS.DEFAULT | FLAGS.V + }); + }); + + it('should BIT abs', function() { + initMemory([[0x03, 0x33, [0xAA]]]); + testCode([0x2C, 0x33, 0x03], 1, { + }, { + cycles: 4, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.Z + }); + }); + }); + + describe('#math', function() { + // ********** ADC + it('should ADC', function () { + testCode([0x69, 0x55], 1, { + a: 0x23 + }, { + cycles: 2, + a: 0x78, + s: FLAGS.DEFAULT + }); + }); + + it('should ADC with carry in', function () { + testCode([0x69, 0x55], 1, { + a: 0x23, + s: FLAGS.DEFAULT | FLAGS.C + }, { + cycles: 2, + a: 0x79, + s: FLAGS.DEFAULT + }); + }); + + it('should ADC with overflow out', function () { + testCode([0x69, 0x55], 1, { + a: 0x2B + }, { + cycles: 2, + a: 0x80, + s: FLAGS.DEFAULT | FLAGS.N | FLAGS.V + }); + }); + + it('should ADC with carry out', function () { + testCode([0x69, 0x55], 1, { + a: 0xBB + }, { + cycles: 2, + a: 0x10, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** ADC BCD + it('should ADC BCD', function () { + testCode([0x69, 0x16], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x25 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.V, + a: 0x41 + }); + }); + + it('should ADC BCD with carry in', function () { + testCode([0x69, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + s: FLAGS.DEFAULT| FLAGS.D | FLAGS.V, + a: 0x79 + }); + }); + + it('should ADC BCD with carry out', function () { + testCode([0x69, 0x10], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x91 + }, { + cycles: 2, + a: 0x01, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + // ********** SBC + it('should SBC', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + a: 0x32, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should SBC with borrow in', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT, + a: 0x55 + }, { + cycles: 2, + a: 0x31, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + it('should SBC with borrow out', function () { + testCode([0xE9, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + a: 0xCE, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should SBC with overflow out', function () { + testCode([0xE9, 0x7F], 1, { + s: FLAGS.DEFAULT | FLAGS.C, + a: 0xAF + }, { + cycles: 2, + a: 0x30, + s: FLAGS.DEFAULT | FLAGS.V | FLAGS.C + }); + }); + + // ********** SBC BCD + it('should SBC BCD', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x55 + }, { + cycles: 2, + a: 0x32, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + it('should SBC BCD with borrow in', function () { + testCode([0xE9, 0x23], 1, { + s: FLAGS.DEFAULT | FLAGS.D, + a: 0x55 + }, { + cycles: 2, + a: 0x31, + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C + }); + }); + + it('should SBC BCD with borrow out', function () { + testCode([0xE9, 0x55], 1, { + s: FLAGS.DEFAULT | FLAGS.D | FLAGS.C, + a: 0x23 + }, { + cycles: 2, + a: 0x68, + s: FLAGS.DEFAULT | FLAGS.D + }); + }); + + // ********** INC + it('should INC zp', function() { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xE6, 0x33], 1, { + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x45]]]); + }); + + it('should INC zp,x', function() { + initMemory([[0x00, 0x043, [0x44]]]); + testCode([0xF6, 0x33], 1, { + x: 0x10 + }, { + cycles: 6 + }); + expectMemory([[0x00, 0x43, [0x45]]]); + }); + + it('should INC abs', function() { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xEE, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x45]]]); + }); + + it('should INC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xFE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x45]]]); + }); + + // ********** DEC + it('should DEC zp', function() { + initMemory([[0x00, 0x33, [0x44]]]); + testCode([0xC6, 0x33], 1, { + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x43]]]); + }); + + it('should DEC zp,x', function() { + initMemory([[0x00, 0x043, [0x44]]]); + testCode([0xD6, 0x33], 1, { + x: 0x10 + }, { + cycles: 6 + }); + expectMemory([[0x00, 0x43, [0x43]]]); + }); + + it('should DEC abs', function() { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0xCE, 0x33, 0x03], 1, { + }, { + cycles: 6 + }); + expectMemory([[0x03, 0x33, [0x43]]]); + }); + + it('should DEC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xDE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x43]]]); + }); + }); + + describe('#comparison', function() { + // ********** CMP + it('should CMP less than', function() { + testCode([0xc9, 0x44], 1, { + a: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CMP equal', function() { + testCode([0xc9, 0x44], 1, { + a: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CMP greater than', function() { + testCode([0xc9, 0x44], 1, { + a: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** CPX + it('should CPX less than', function() { + testCode([0xE0, 0x44], 1, { + x: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CPX equal', function() { + testCode([0xE0, 0x44], 1, { + x: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CPX greater than', function() { + testCode([0xE0, 0x44], 1, { + x: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + + // ********** CPY + it('should CPY less than', function() { + testCode([0xE0, 0x44], 1, { + y: 0x33 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.N + }); + }); + + it('should CPY equal', function() { + testCode([0xc0, 0x44], 1, { + y: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.C + }); + }); + + it('should CPY greater than', function() { + testCode([0xc0, 0x44], 1, { + y: 0x55 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.C + }); + }); + }); + + describe('#utility', function() { + it('should list', function() { + var listing = cpu.list(0xff00); + expect(listing[0]).toEqual('FF00- 00 00 BRK #$00'); + }); + + it('should list with symbols', function() { + var listing = cpu.list(0xff00, {0x00: 'ZERO', 0xFF00: 'ENTRY'}); + expect(listing[0]).toEqual('FF00- ENTRY 00 00 BRK #ZERO'); + }); + + it('should dump page', function() { + var page = cpu.dumpPage(0xff); + expect(page).toContain('FF80: 48 45 4C 4C 4F 0D 00 00 00 00 00 00 00 00 00 00 HELLO...........'); + }); + + it('should dump registers', function() { + var regs = cpu.dumpRegisters(); + expect(regs).toEqual('0000- A=00 X=00 Y=00 P=20 S=FF --------'); + }); + }); +}); + +describe('65c02', function() { + beforeEach(function() { + cpu = new CPU6502({'65C02': true}); + memory = new Memory(4); + + cpu.addPageHandler(memory); + cpu.addPageHandler(bios); + }); + + describe('#signals', function() { + it('should clear D on IRQ', function() { + initState({ + s: FLAGS.DEFAULT | FLAGS.D + }); + + cpu.irq(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should clear D on NMI', function() { + initState({ + s: FLAGS.DEFAULT | FLAGS.D + }); + + cpu.nmi(); + + expectState(DEFAULT_STATE, { + cycles: 5, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + + it('should clear D on BRK', function () { + testCode([0x00, 0x00], 1, { + s: FLAGS.DEFAULT | FLAGS.D + }, { + cycles: 7, + s: FLAGS.DEFAULT | FLAGS.I, + sp: 0xfc, + pc: 0xff00 + }); + }); + }); + + describe('#stack', function() { + it('should PHX', function() { + testCode([0xDA], 1, { + x: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLX', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0xFA], 1, { + sp: 0xfe + }, { + cycles: 4, + x: 0x44, + sp: 0xff + }); + }); + + it('should PHY', function() { + testCode([0x5A], 1, { + y: 0x44 + }, { + cycles: 3, + sp: 0xfe + }); + expectStack([0x44]); + }); + + it('should PLY', function() { + initMemory([[0x01, 0xff, [0x44]]]); + testCode([0x7A], 1, { + sp: 0xfe + }, { + cycles: 4, + y: 0x44, + sp: 0xff + }); + }); + + }); + + describe('#jumps', function() { + it('should JMP (abs)', function () { + initMemory([[0x03, 0x33, [0x34, 0x12]]]); + testCode([0x6C, 0x33, 0x03], 1, {}, { + cycles: 6, + pc: 0x1234 + }); + }); + + it('should JMP (abs) across page boundries without bugs', function () { + initMemory([[0x02, 0xFF, [0x34, 0x12]], + [0x02, 0x00, [0xff]]]); + testCode([0x6C, 0xFF, 0x02], 1, {}, { + cycles: 6, + pc: 0x1234 + }); + }); + + it('should JMP (abs, x)', function () { + initMemory([[0x03, 0x43, [0x34, 0x12]]]); + testCode([0x7C, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 6, + pc: 0x1234 + }); + }); + }); + + describe('#other addressing mode fixes', function () { + it('should INC abs,x', function() { + initMemory([[0x03, 0x043, [0x44]]]); + testCode([0xFE, 0x33, 0x03], 1, { + x: 0x10 + }, { + cycles: 7 + }); + expectMemory([[0x03, 0x43, [0x45]]]); + }); + }); + + describe('#branches', function() { + it('should BRA forward', function () { + testCode([0x80, 0x7F], 1, {}, { + cycles: 3, + pc: 0x0481 + }); + }); + + it('should BRA backward', function () { + testCode([0x80, 0xFF], 1, {}, { + cycles: 3, + pc: 0x0401 + }); + }); + }); + + describe('#read memory', function() { + // ********** (zp) + it('should LDA (zp)', function () { + initMemory([[0x00, 0x33, [0x33,0x03]], + [0x03, 0x33, [0x44]]]); + testCode([0xB2, 0x33], 1, {}, { + cycles: 5, + a: 0x44 + }); + }); + }); + + describe('#write memory', function() { + // ********** (zp) + it('should STA (zp)', function () { + initMemory([[0x00, 0x33, [0x33, 0x03]]]); + testCode([0x92, 0x33], 1, { + a: 0x44 + }, { + cycles: 5 + }); + expectMemory([[0x03, 0x33, [0x44]]]); + }); + + it('should STZ abs', function () { + initMemory([[0x03, 0x33, [0x44]]]); + testCode([0x9C, 0x33, 0x03], 1, { + a: 0x44 + }, { + cycles: 4 + }); + expectMemory([[0x03, 0x33, [0x00]]]); + }); + }); + + describe('#logical operators', function() { + it('should BIT imm and effect other flags', function() { + testCode([0x89, 0x33], 1, { + s: FLAGS.DEFAULT | FLAGS.N, + a: 0x44 + }, { + cycles: 2, + s: FLAGS.DEFAULT | FLAGS.Z | FLAGS.N + }); + }); + + it('should BIT imm', function() { + testCode([0x89, 0x33], 1, { + a: 0x03 + }, { + cycles: 2, + s: FLAGS.DEFAULT + }); + }); + + // ******** TRB + it('should TRB zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x14, 0x33], 1, { + a: 0xA5 + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0x50]]]); + }); + + it('should TRB abs', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x1C, 0x33, 0x03], 1, { + a: 0xAA + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.Z + }); + expectMemory([[0x00, 0x33, [0x00]]]); + }); + + // ******** TSB + it('should TSB zp', function() { + initMemory([[0x00, 0x33, [0x55]]]); + testCode([0x04, 0x33], 1, { + a: 0xA5 + }, { + cycles: 5 + }); + expectMemory([[0x00, 0x33, [0xF5]]]); + }); + + it('should TSB abs', function() { + initMemory([[0x03, 0x33, [0x55]]]); + testCode([0x0C, 0x33, 0x03], 1, { + a: 0xAA + }, { + cycles: 6, + s: FLAGS.DEFAULT | FLAGS.Z + }); + expectMemory([[0x03, 0x33, [0xFF]]]); + }); + }); + + describe('Branch bit set/reset', function () { + // ******** BBR + it('BBR0 should branch if bit 0 clear', function() { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x0F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR0 should branch backward', function () { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x0F, 0x33, 0xFF], 1, {}, { + cycles: 6, + pc: 0x0402 + }); + }); + + it('BBR1 should branch if bit 1 clear', function() { + initMemory([[0x00, 0x33, [0xFD]]]); + testCode([0x1F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR2 should branch if bit 2 clear', function() { + initMemory([[0x00, 0x33, [0xFB]]]); + testCode([0x2F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR3 should branch if bit 3 clear', function() { + initMemory([[0x00, 0x33, [0xF7]]]); + testCode([0x3F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR4 should branch if bit 4 clear', function() { + initMemory([[0x00, 0x33, [0xEF]]]); + testCode([0x4F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR5 should branch if bit 5 clear', function() { + initMemory([[0x00, 0x33, [0xDF]]]); + testCode([0x5F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR6 should branch if bit 6 clear', function() { + initMemory([[0x00, 0x33, [0xBF]]]); + testCode([0x6F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR7 should branch if bit 7 clear', function() { + initMemory([[0x00, 0x33, [0x7F]]]); + testCode([0x7F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBR0 should not branch if bit 0 set', function() { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x0F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR1 should not branch if bit 1 set', function() { + initMemory([[0x00, 0x33, [0x02]]]); + testCode([0x1F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR2 should not branch if bit 2 set', function() { + initMemory([[0x00, 0x33, [0x04]]]); + testCode([0x2F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR3 should not branch if bit 3 set', function() { + initMemory([[0x00, 0x33, [0x08]]]); + testCode([0x3F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR4 should not branch if bit 4 set', function() { + initMemory([[0x00, 0x33, [0x10]]]); + testCode([0x4F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR5 should not branch if bit 5 set', function() { + initMemory([[0x00, 0x33, [0x20]]]); + testCode([0x5F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR6 should not branch if bit 6 set', function() { + initMemory([[0x00, 0x33, [0x40]]]); + testCode([0x6F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBR7 should not branch if bit 7 set', function() { + initMemory([[0x00, 0x33, [0x80]]]); + testCode([0x7F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + // ******** BBS + it('BBS0 should branch if bit 0 set', function() { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x8F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS0 should branch backward', function () { + initMemory([[0x00, 0x33, [0x01]]]); + testCode([0x8F, 0x33, 0xFF], 1, {}, { + cycles: 6, + pc: 0x0402 + }); + }); + + it('BBS1 should branch if bit 1 set', function() { + initMemory([[0x00, 0x33, [0x02]]]); + testCode([0x9F, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS2 should branch if bit 2 set', function() { + initMemory([[0x00, 0x33, [0x04]]]); + testCode([0xAF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS3 should branch if bit 3 set', function() { + initMemory([[0x00, 0x33, [0x08]]]); + testCode([0xBF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS4 should branch if bit 4 set', function() { + initMemory([[0x00, 0x33, [0x10]]]); + testCode([0xCF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS5 should branch if bit 5 set', function() { + initMemory([[0x00, 0x33, [0x20]]]); + testCode([0xDF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS6 should branch if bit 6 set', function() { + initMemory([[0x00, 0x33, [0x40]]]); + testCode([0xEF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS7 should branch if bit 7 set', function() { + initMemory([[0x00, 0x33, [0x80]]]); + testCode([0xFF, 0x33, 0x7F], 1, {}, { + cycles: 6, + pc: 0x0482 + }); + }); + + it('BBS0 should not branch if bit 0 clear', function() { + initMemory([[0x00, 0x33, [0xFE]]]); + testCode([0x8F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS1 should not branch if bit 1 clear', function() { + initMemory([[0x00, 0x33, [0xFD]]]); + testCode([0x9F, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS2 should not branch if bit 2 clear', function() { + initMemory([[0x00, 0x33, [0xFB]]]); + testCode([0xAF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS3 should not branch if bit 3 clear', function() { + initMemory([[0x00, 0x33, [0xF7]]]); + testCode([0xBF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS4 should not branch if bit 4 clear', function() { + initMemory([[0x00, 0x33, [0xEF]]]); + testCode([0xCF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS5 should not branch if bit 5 clear', function() { + initMemory([[0x00, 0x33, [0xDF]]]); + testCode([0xDF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS6 should not branch if bit 6 clear', function() { + initMemory([[0x00, 0x33, [0xBF]]]); + testCode([0xEF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + + it('BBS7 should not branch if bit 7 clear', function() { + initMemory([[0x00, 0x33, [0x7B]]]); + testCode([0xFF, 0x33, 0x7F], 1, {}, { + cycles: 5, + pc: 0x0403 + }); + }); + }); + + describe('Bit set/reset', function () { + it('RMB0 should reset bit 0', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x07, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFE]]]); + }); + + it('RMB1 should reset bit 1', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x17, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFD]]]); + }); + + it('RMB2 should reset bit 2', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x27, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xFB]]]); + }); + + it('RMB3 should reset bit 3', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x37, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xF7]]]); + }); + + it('RMB4 should reset bit 4', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x47, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xEF]]]); + }); + + it('RMB5 should reset bit 5', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x57, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xDF]]]); + }); + + it('RMB6 should reset bit 6', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x67, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0xBF]]]); + }); + + it('RMB7 should reset bit 7', function() { + initMemory([[0x00, 0x33, [0xFF]]]); + testCode([0x77, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x7F]]]); + }); + + it('SMB0 should set bit 0', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0x87, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x01]]]); + }); + + it('SMB1 should set bit 1', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0x97, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x02]]]); + }); + + it('SMB2 should set bit 2', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xA7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x04]]]); + }); + + it('SMB3 should set bit 3', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xB7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x08]]]); + }); + + it('SMB4 should set bit 4', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xC7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x10]]]); + }); + + it('SMB5 should set bit 5', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xD7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x20]]]); + }); + + it('SMB6 should set bit 6', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xE7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x40]]]); + }); + + it('SMB7 should set bit 7', function() { + initMemory([[0x00, 0x33, [0x00]]]); + testCode([0xF7, 0x33], 1, {}, { + cycles: 5, + pc: 0x0402 + }); + expectMemory([[0x00, 0x33, [0x80]]]); + }); + }); + + describe('#math', function() { + // INC A + it('should INC A', function() { + testCode([0x1A], 1, { + a: 0x44 + },{ + cycles: 2, + a: 0x45 + }); + }); + + // DEC A + it('should DEC A', function() { + testCode([0x3A], 1, { + a: 0x44 + },{ + cycles: 2, + a: 0x43 + }); + }); + }); +}); diff --git a/webpack.config.js b/webpack.config.js index 96a71dc5..513efeac 100644 --- a/webpack.config.js +++ b/webpack.config.js @@ -5,7 +5,8 @@ module.exports = devtool: 'source-map', entry: { main2: path.resolve('js/entry2.js'), - main2e: path.resolve('js/entry2e.js') + main2e: path.resolve('js/entry2e.js'), + cpu_benchmark: path.resolve('test/perf/cpu_benchmark.js') }, output: { path: path.resolve('dist/'), From fad720ddf6013a6437e803d212fdfe4934cfeb45 Mon Sep 17 00:00:00 2001 From: Ian Flanigan Date: Sun, 8 Nov 2020 11:39:35 +0100 Subject: [PATCH 2/2] Add tscpu6502v6.ts from PR #40's cpu6502.ts Running the performance tests shows that the previous version was actually slightly faster. --- test/perf/cpu_benchmark.js | 16 +- test/perf/impl/tscpu6502v6.ts | 1718 +++++++++++++++++ ...scpu6502v5.spec.js => tscpu6502v6.spec.js} | 2 +- 3 files changed, 1734 insertions(+), 2 deletions(-) create mode 100644 test/perf/impl/tscpu6502v6.ts rename test/{tscpu6502v5.spec.js => tscpu6502v6.spec.js} (99%) diff --git a/test/perf/cpu_benchmark.js b/test/perf/cpu_benchmark.js index b7b88706..2b6bd6cf 100644 --- a/test/perf/cpu_benchmark.js +++ b/test/perf/cpu_benchmark.js @@ -2,6 +2,7 @@ import JSCPU6502 from './impl/jscpu6502'; import TSCPU6502 from './impl/tscpu6502'; import TSCPU6502v2 from './impl/tscpu6502v2'; import TSCPU6502v5 from './impl/tscpu6502v5'; +import TSCPU6502v6 from './impl/tscpu6502v6'; import Test6502 from './test6502rom'; import Test65C02 from './test65c02rom'; @@ -96,10 +97,23 @@ const tests = [ test: () => runCPU(0x3469, 30648245), }, // { - // id: 'tsv5_65C02', + // impl: 'cpu6502v5.ts', + // emul: '6502', // setup: () => setup65C02(TSCPU6502v5), // test: () => runCPU(0x24f1, 21987280), // }, + { + impl: 'cpu6502v6.ts', + emul: '6502', + setup: () => setup6502(TSCPU6502v6), + test: () => runCPU(0x3469, 30648245), + }, + { + impl: 'cpu6502v6.ts', + emul: '65C02', + setup: () => setup65C02(TSCPU6502v6), + test: () => runCPU(0x24f1, 21987280), + }, ]; const IMPLS = [...new Set(tests.map((e) => e.impl))]; diff --git a/test/perf/impl/tscpu6502v6.ts b/test/perf/impl/tscpu6502v6.ts new file mode 100644 index 00000000..9d49985e --- /dev/null +++ b/test/perf/impl/tscpu6502v6.ts @@ -0,0 +1,1718 @@ +/* + * Copyright 2010-2019 Will Scullin + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +import { byte, word } from '../../../js/types'; +import { debug, toHex } from '../../../js/util'; + +type symbols = { [key: number]: string }; + +export interface CpuOptions { + '65C02'?: boolean; +} + +export interface CpuState { + a: byte, + x: byte, + y: byte, + s: byte, + pc: word, + sp: byte, + cycles: number +} + +type Mode = + 'accumulator' | // A (Accumulator) + 'implied' | // Implied + 'immediate' | // # Immediate + 'absolute' | // a Absolute + 'zeroPage' | // zp Zero Page + 'relative' | // r Relative + 'absoluteX' | // a,X Absolute, X + 'absoluteY' | // a,Y Absolute, Y + 'zeroPageX' | // zp,X Zero Page, X + 'zeroPageY' | // zp,Y Zero Page, Y + 'absoluteIndirect' | // (a) Indirect + 'zeroPageXIndirect' | // (zp,X) Zero Page Indexed Indirect + 'zeroPageIndirectY' | // (zp),Y Zero Page Indexed with Y + 'zeroPageIndirect' | // (zp), + 'absoluteXIndirect' | // (a, X), + 'zeroPage_relative'; // zp, Relative + +type Modes = Record; + +/** Addressing mode name to instruction size mapping. */ +const sizes: Modes = { + accumulator: 1, + implied: 1, + immediate: 2, + absolute: 3, + zeroPage: 2, + relative: 2, + + absoluteX: 3, + absoluteY: 3, + zeroPageX: 2, + zeroPageY: 2, + + absoluteIndirect: 3, + zeroPageXIndirect: 2, + zeroPageIndirectY: 2, + + /* 65c02 */ + zeroPageIndirect: 2, + absoluteXIndirect: 3, + zeroPage_relative: 3 +}; + +/** Status register flag numbers. */ +type flag = 0x80 | 0x40 | 0x20 | 0x10 | 0x08 | 0x04 | 0x02 | 0x01; + +/** Flags to status byte mask. */ +const flags: {[key: string]: flag} = { + N: 0x80, // Negative + V: 0x40, // oVerflow + B: 0x10, // Break + D: 0x08, // Decimal + I: 0x04, // Interrupt + Z: 0x02, // Zero + C: 0x01 // Carry +}; + +/** CPU-referenced memory locations. */ +const loc = { + STACK: 0x100, + NMI: 0xFFFA, + RESET: 0xFFFC, + BRK: 0xFFFE +}; + +export interface ReadablePage { + read(page: byte, offset: byte): byte; +} + +function isReadablePage(page: ReadablePage | any): page is ReadablePage { + return (page as ReadablePage).read !== undefined; +} + +export interface WriteablePage { + write(page: byte, offset: byte, value: byte): void; +} + +function isWriteablePage(page: WriteablePage | any): page is WriteablePage { + return (page as WriteablePage).write !== undefined; +} + +export interface PageHandler { + start(): byte; + end(): byte; +} + +function isResettablePageHandler(pageHandler: PageHandler | ResettablePageHandler): pageHandler is ResettablePageHandler { + return (pageHandler as ResettablePageHandler).reset !== undefined; +} + +interface ResettablePageHandler extends PageHandler { + reset(): void; +} + +const BLANK_PAGE: ReadablePage & WriteablePage = { + read: function() { return 0; }, + write: function() {} +}; + +interface Opts { + rwm?: boolean; +} + +type ReadFn = () => byte; +type WriteFn = (val: byte) => void; +type ReadAddrFn = (opts?: Opts) => word; +type ImpliedFn = () => void + +interface Op { + name: string + mode: keyof Modes + op: (fn: T) => void + modeFn: T +} + +type Instruction = Op + +interface Instructions { + [key: number]: Instruction; +} + +type callback = (cpu: any) => void; // TODO(flan): Hack until there is better typing. + +export default class CPU6502 { + private readonly is65C02; + + /* Registers */ + private pc = 0; // Program Counter + private sr = 0x20; // Process Status Register + private ar = 0; // Accumulator + private xr = 0; // X Register + private yr = 0; // Y Register + private sp = 0xff; // Stack Pointer + + private readPages: ReadablePage[] = []; + private writePages: WriteablePage[] = []; + private resetHandlers: ResettablePageHandler[] = []; + private cycles = 0; + private sync = false; + + private readonly ops: Instructions; + private readonly opary: Instruction[]; + + constructor(options: CpuOptions = {}) { + this.is65C02 = options['65C02'] ? true : false; + + for (let idx = 0; idx < 0x100; idx++) { + this.readPages[idx] = BLANK_PAGE; + this.writePages[idx] = BLANK_PAGE; + } + + // Create this CPU's instruction table + + let ops: Instructions = { ...this.OPS_6502 }; + if (this.is65C02) { + ops = { ...ops, ...this.OPS_65C02 }; + } + this.ops = ops; + + // Certain browsers benefit from using arrays over maps + const opary: Instruction[] = []; + + for (let idx = 0; idx < 0x100; idx++) { + opary[idx] = ops[idx] || this.unknown(idx); + } + this.opary = opary; + } + + /** + * Set or clears `f` in the status register. `f` must be a byte with a + * single bit set. + */ + private setFlag(f: byte, on: boolean) { + this.sr = on ? (this.sr | f) : (this.sr & ~f); + } + + /** Updates the status register's zero flag and negative flag. */ + private testNZ(val: byte) { + this.sr = val === 0 ? (this.sr | flags.Z) : (this.sr & ~flags.Z); + this.sr = (val & 0x80) ? (this.sr | flags.N) : (this.sr & ~flags.N); + + return val; + } + + /** Updates the status register's zero flag. */ + private testZ(val: byte) { + this.sr = val === 0 ? (this.sr | flags.Z) : (this.sr & ~flags.Z); + + return val; + } + + /** + * Returns `a + b`, unless `sub` is true, in which case it performs + * `a - b`. The status register is updated according to the result. + */ + private add(a: byte, b: byte, sub: boolean) { + if (sub) + b ^= 0xff; + + // KEGS + let c, v; + if ((this.sr & flags.D) !== 0) { + // BCD + c = (a & 0x0f) + (b & 0x0f) + (this.sr & flags.C); + if (sub) { + if (c < 0x10) + c = (c - 0x06) & 0x0f; + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c < 0x100) + c = (c + 0xa0) & 0xff; + } else { + if (c > 0x09) + c = (c - 0x0a) | 0x10; // carry to MSN + c += (a & 0xf0) + (b & 0xf0); + v = (c >> 1) ^ c; + if (c > 0x99) + c += 0x60; + } + } else { + c = a + b + (this.sr & flags.C); + v = (c ^ a) & 0x80; + } + + if (((a ^ b) & 0x80) !== 0) { + v = 0; + } + + this.setFlag(flags.C, c > 0xff); + this.setFlag(flags.V, !!v); + + return this.testNZ(c & 0xff); + } + + /** Increments `a` and returns the value, setting the status register. */ + private increment(a: byte) { + return this.testNZ((a + 0x01) & 0xff); + } + + private decrement(a: byte) { + return this.testNZ((a + 0xff) & 0xff); + } + + private readBytePC(): byte { + const addr = this.pc, + page = addr >> 8, + off = addr & 0xff; + + const result = this.readPages[page].read(page, off); + + this.pc = (this.pc + 1) & 0xffff; + + this.cycles++; + + return result; + } + + private readByte(addr: word): byte { + const page = addr >> 8, + off = addr & 0xff; + + const result = this.readPages[page].read(page, off); + + this.cycles++; + + return result; + } + + private readByteDebug(addr: word) { + const page = addr >> 8, + off = addr & 0xff; + + return this.readPages[page].read(page, off); + } + + private writeByte(addr: word, val: byte) { + const page = addr >> 8, + off = addr & 0xff; + + this.writePages[page].write(page, off, val); + + this.cycles++; + } + + private readWord(addr: word): word { + return this.readByte(addr) | (this.readByte(addr + 1) << 8); + } + + private readWordDebug(addr: word): word { + return this.readByteDebug(addr) | (this.readByteDebug(addr + 1) << 8); + } + + private readWordPC(): word { + return this.readBytePC() | (this.readBytePC() << 8); + } + + private readZPWord(addr: byte): word { + const lsb = this.readByte(addr & 0xff); + const msb = this.readByte((addr + 1) & 0xff); + + return (msb << 8) | lsb; + } + + private pushByte(val: byte) { + this.writeByte(loc.STACK | this.sp, val); + this.sp = (this.sp + 0xff) & 0xff; + } + + private pushWord(val: word) { + this.pushByte(val >> 8); + this.pushByte(val & 0xff); + } + + private pullByte(): byte { + this.sp = (this.sp + 0x01) & 0xff; + return this.readByte(loc.STACK | this.sp); + } + + private pullWordRaw(): word { + const lsb = this.pullByte(); + const msb = this.pullByte(); + + return (msb << 8) | lsb; + } + + /* + * Implied function + */ + + implied() { + } + + /* + * Read functions + */ + + // #$00 + readImmediate = (): byte => { + return this.readBytePC(); + } + + // $0000 + readAbsolute = (): byte => { + return this.readByte(this.readWordPC()); + } + + // $00 + readZeroPage= (): byte => { + return this.readByte(this.readBytePC()); + } + + // $0000,X + readAbsoluteX= (): byte => { + let addr = this.readWordPC(); + const oldPage = addr >> 8; + addr = (addr + this.xr) & 0xffff; + const newPage = addr >> 8; + if (newPage != oldPage) { + const off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // $0000,Y + readAbsoluteY = (): byte => { + let addr = this.readWordPC(); + const oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + const newPage = addr >> 8; + if (newPage != oldPage) { + const off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // $00,X + readZeroPageX = (): byte => { + const zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return this.readByte((zpAddr + this.xr) & 0xff); + } + + // $00,Y + readZeroPageY = (): byte => { + const zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return this.readByte((zpAddr + this.yr) & 0xff); + } + + // ($00,X) + readZeroPageXIndirect = (): byte => { + const zpAddr = this.readBytePC(); + this.readByte(zpAddr); + const addr = this.readZPWord((zpAddr + this.xr) & 0xff); + return this.readByte(addr); + } + + // ($00),Y + readZeroPageIndirectY = (): byte => { + let addr = this.readZPWord(this.readBytePC()); + const oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + const newPage = addr >> 8; + if (newPage != oldPage) { + const off = addr & 0xff; + this.readByte(oldPage << 8 | off); + } + return this.readByte(addr); + } + + // ($00) (65C02) + readZeroPageIndirect = (): byte => { + return this.readByte(this.readZPWord(this.readBytePC())); + } + + /* + * Write Functions + */ + + // $0000 + writeAbsolute = (val: byte) => { + this.writeByte(this.readWordPC(), val); + } + + // $00 + writeZeroPage = (val: byte) => { + this.writeByte(this.readBytePC(), val); + } + + // $0000,X + writeAbsoluteX = (val: byte) => { + let addr = this.readWordPC(); + const oldPage = addr >> 8; + addr = (addr + this.xr) & 0xffff; + const off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // $0000,Y + writeAbsoluteY = (val: byte) => { + let addr = this.readWordPC(); + const oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + const off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // $00,X + writeZeroPageX = (val: byte) => { + const zpAddr = this.readBytePC(); + this.readByte(zpAddr); + this.writeByte((zpAddr + this.xr) & 0xff, val); + } + + // $00,Y + writeZeroPageY = (val: byte) => { + const zpAddr = this.readBytePC(); + this.readByte(zpAddr); + this.writeByte((zpAddr + this.yr) & 0xff, val); + } + + // ($00,X) + writeZeroPageXIndirect = (val: byte) => { + const zpAddr = this.readBytePC(); + this.readByte(zpAddr); + const addr = this.readZPWord((zpAddr + this.xr) & 0xff); + this.writeByte(addr, val); + } + + // ($00),Y + writeZeroPageIndirectY = (val: byte) => { + let addr = this.readZPWord(this.readBytePC()); + const oldPage = addr >> 8; + addr = (addr + this.yr) & 0xffff; + const off = addr & 0xff; + this.readByte(oldPage << 8 | off); + this.writeByte(addr, val); + } + + // ($00) (65C02) + writeZeroPageIndirect = (val: byte) => { + this.writeByte(this.readZPWord(this.readBytePC()), val); + } + + // $00 + readAddrZeroPage = (): byte => { + return this.readBytePC(); + } + + // $00,X + readAddrZeroPageX = () => { + const zpAddr = this.readBytePC(); + this.readByte(zpAddr); + return (zpAddr + this.xr) & 0xff; + } + + // $0000 (65C02) + readAddrAbsolute = (): word => { + return this.readWordPC(); + } + + // ($0000) (6502) + readAddrAbsoluteIndirectBug = (): word => { + const addr = this.readWordPC(); + const page = addr & 0xff00; + const off = addr & 0x00ff; + const lsb = this.readByte(addr); + const msb = this.readByte(page | ((off + 0x01) & 0xff)); + return msb << 8 | lsb; + } + + // ($0000) (65C02) + readAddrAbsoluteIndirect = (): word => { + const lsb = this.readBytePC(); + const msb = this.readBytePC(); + this.readByte(this.pc); + return this.readWord(msb << 8 | lsb); + } + + // $0000,X + readAddrAbsoluteX = (opts: Opts = {}): word => { + const addr = this.readWordPC(); + if (!this.is65C02 || opts.rwm) { + this.readByte(addr); + } else { + this.readByte(this.pc); + } + return (addr + this.xr) & 0xffff; + } + + // $(0000,X) (65C02) + readAddrAbsoluteXIndirect = (): word => { + const address = this.readWordPC(); + this.readByte(this.pc); + return this.readWord((address + this.xr) & 0xffff); + } + + /* Break */ + brk = (readFn: ReadFn) => { + readFn(); + this.pushWord(this.pc); + this.pushByte(this.sr | flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.BRK); + } + + /* Load Accumulator */ + lda = (readFn: ReadFn) => { + this.ar = this.testNZ(readFn()); + } + + /* Load X Register */ + ldx = (readFn: ReadFn) => { + this.xr = this.testNZ(readFn()); + } + + /* Load Y Register */ + ldy = (readFn: ReadFn) => { + this.yr = this.testNZ(readFn()); + } + + /* Store Accumulator */ + sta = (writeFn: WriteFn) => { + writeFn(this.ar); + } + + /* Store X Register */ + stx = (writeFn: WriteFn) => { + writeFn(this.xr); + } + + /* Store Y Register */ + sty = (writeFn: WriteFn) => { + writeFn(this.yr); + } + + /* Store Zero */ + stz = (writeFn: WriteFn) => { + writeFn(0); + } + + /* Add with Carry */ + adc = (readFn: ReadFn) => { + this.ar = this.add(this.ar, readFn(), /* sub= */ false); + } + + /* Subtract with Carry */ + sbc = (readFn: ReadFn) => { + this.ar = this.add(this.ar, readFn(), /* sub= */ true); + } + + /* Increment Memory */ + incA = () => { + this.readByte(this.pc); + this.ar = this.increment(this.ar); + } + + inc = (readAddrFn: ReadAddrFn) => { + const addr = readAddrFn({rwm: true}); + const oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + const val = this.increment(oldVal); + this.writeByte(addr, val); + } + + /* Increment X */ + inx = () => { + this.readByte(this.pc); + this.xr = this.increment(this.xr); + } + + /* Increment Y */ + iny = () => { + this.readByte(this.pc); + this.yr = this.increment(this.yr); + } + + /* Decrement Memory */ + decA = () => { + this.readByte(this.pc); + this.ar = this.decrement(this.ar); + } + + dec = (readAddrFn: ReadAddrFn) => { + const addr = readAddrFn({rwm: true}); + const oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + const val = this.decrement(oldVal); + this.writeByte(addr, val); + } + + /* Decrement X */ + dex = () => { + this.readByte(this.pc); + this.xr = this.decrement(this.xr); + } + + /* Decrement Y */ + dey = () => { + this.readByte(this.pc); + this.yr = this.decrement(this.yr); + } + + shiftLeft = (val: byte) => { + this.setFlag(flags.C, !!(val & 0x80)); + return this.testNZ((val << 1) & 0xff); + } + + /* Arithmetic Shift Left */ + aslA = () => { + this.readByte(this.pc); + this.ar = this.shiftLeft(this.ar); + } + + asl = (readAddrFn: ReadAddrFn) => { + const addr = readAddrFn({rwm: true}); + const oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + const val = this.shiftLeft(oldVal); + this.writeByte(addr, val); + } + + shiftRight = (val: byte) => { + this.setFlag(flags.C, !!(val & 0x01)); + return this.testNZ(val >> 1); + } + + /* Logical Shift Right */ + lsrA = () => { + this.readByte(this.pc); + this.ar = this.shiftRight(this.ar); + } + + lsr = (readAddrFn: ReadAddrFn) => { + const addr = readAddrFn({rwm: true}); + const oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + const val = this.shiftRight(oldVal); + this.writeByte(addr, val); + } + + rotateLeft = (val: byte) => { + const c = (this.sr & flags.C); + this.setFlag(flags.C, !!(val & 0x80)); + return this.testNZ(((val << 1) | (c ? 0x01 : 0x00)) & 0xff); + } + + /* Rotate Left */ + rolA = () => { + this.readByte(this.pc); + this.ar = this.rotateLeft(this.ar); + } + + rol = (readAddrFn: ReadAddrFn) => { + const addr = readAddrFn({rwm: true}); + const oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + const val = this.rotateLeft(oldVal); + this.writeByte(addr, val); + } + + private rotateRight(a: byte) { + const c = (this.sr & flags.C); + this.setFlag(flags.C, !!(a & 0x01)); + return this.testNZ((a >> 1) | (c ? 0x80 : 0x00)); + } + + /* Rotate Right */ + rorA = () => { + this.readByte(this.pc); + this.ar = this.rotateRight(this.ar); + } + + ror = (readAddrFn: ReadAddrFn) => { + const addr = readAddrFn({rwm: true}); + const oldVal = this.readByte(addr); + this.writeByte(addr, oldVal); + const val = this.rotateRight(oldVal); + this.writeByte(addr, val); + } + + /* Logical And Accumulator */ + and = (readFn: ReadFn) => { + this.ar = this.testNZ(this.ar & readFn()); + } + + /* Logical Or Accumulator */ + ora = (readFn: ReadFn) => { + this.ar = this.testNZ(this.ar | readFn()); + } + + /* Logical Exclusive Or Accumulator */ + eor = (readFn: ReadFn) => { + this.ar = this.testNZ(this.ar ^ readFn()); + } + + /* Reset Bit */ + + rmb = (b: byte) => { + const bit = (0x1 << b) ^ 0xFF; + const addr = this.readBytePC(); + let val = this.readByte(addr); + this.readByte(addr); + val &= bit; + this.writeByte(addr, val); + } + + /* Set Bit */ + + smb = (b: byte) => { + const bit = 0x1 << b; + const addr = this.readBytePC(); + let val = this.readByte(addr); + this.readByte(addr); + val |= bit; + this.writeByte(addr, val); + } + + /* Test and Reset Bits */ + trb = (readAddrFn: ReadAddrFn) => { + const addr = readAddrFn(); + const val = this.readByte(addr); + this.testZ(val & this.ar); + this.readByte(addr); + this.writeByte(addr, val & ~this.ar); + } + + /* Test and Set Bits */ + tsb = (readAddrFn: ReadAddrFn) => { + const addr = readAddrFn(); + const val = this.readByte(addr); + this.testZ(val & this.ar); + this.readByte(addr); + this.writeByte(addr, val | this.ar); + } + + /* Bit */ + bit = (readFn: ReadFn) => { + const val = readFn(); + this.setFlag(flags.Z, (val & this.ar) === 0); + this.setFlag(flags.N, !!(val & 0x80)); + this.setFlag(flags.V, !!(val & 0x40)); + } + + /* Bit Immediate*/ + bitI = (readFn: ReadFn) => { + const val = readFn(); + this.setFlag(flags.Z, (val & this.ar) === 0); + } + + private compare(a: byte, b: byte) { + b = (b ^ 0xff); + const c = a + b + 1; + this.setFlag(flags.C, c > 0xff); + this.testNZ(c & 0xff); + } + + cmp = (readFn: ReadFn) => { + this.compare(this.ar, readFn()); + } + + cpx = (readFn: ReadFn) => { + this.compare(this.xr, readFn()); + } + + cpy = (readFn: ReadFn) => { + this.compare(this.yr, readFn()); + } + + /* Branches */ + brs = (f: flag) => { + const off = this.readBytePC(); // changes pc + if ((f & this.sr) !== 0) { + this.readByte(this.pc); + const oldPage = this.pc >> 8; + this.pc += off > 127 ? off - 256 : off; + const newPage = this.pc >> 8; + const newOff = this.pc & 0xff; + if (newPage != oldPage) this.readByte(oldPage << 8 | newOff); + } + } + + brc = (f: flag) => { + const off = this.readBytePC(); // changes pc + if ((f & this.sr) === 0) { + this.readByte(this.pc); + const oldPage = this.pc >> 8; + this.pc += off > 127 ? off - 256 : off; + const newPage = this.pc >> 8; + const newOff = this.pc & 0xff; + if (newPage != oldPage) this.readByte(oldPage << 8 | newOff); + } + } + + /* WDC 65C02 branches */ + + bbr = (b: byte) => { + const zpAddr = this.readBytePC(); + const val = this.readByte(zpAddr); + this.readByte(zpAddr); + const off = this.readBytePC(); // changes pc + + if (((1 << b) & val) === 0) { + const oldPc = this.pc; + const oldPage = oldPc >> 8; + this.readByte(oldPc); + this.pc += off > 127 ? off - 256 : off; + const newPage = this.pc >> 8; + if (oldPage != newPage) { + this.readByte(oldPc); + } + } + } + + bbs = (b: byte) => { + const zpAddr = this.readBytePC(); + const val = this.readByte(zpAddr); + this.readByte(zpAddr); + const off = this.readBytePC(); // changes pc + + if (((1 << b) & val) !== 0) { + const oldPc = this.pc; + const oldPage = oldPc >> 8; + this.readByte(oldPc); + this.pc += off > 127 ? off - 256 : off; + const newPage = this.pc >> 8; + if (oldPage != newPage) { + this.readByte(oldPc); + } + } + } + + /* Transfers and stack */ + tax = () => { this.readByte(this.pc); this.testNZ(this.xr = this.ar); } + + txa = () => { this.readByte(this.pc); this.testNZ(this.ar = this.xr); } + + tay = () => { this.readByte(this.pc); this.testNZ(this.yr = this.ar); } + + tya = () => { this.readByte(this.pc); this.testNZ(this.ar = this.yr); } + + tsx = () => { this.readByte(this.pc); this.testNZ(this.xr = this.sp); } + + txs = () => { this.readByte(this.pc); this.sp = this.xr; } + + pha = () => { this.readByte(this.pc); this.pushByte(this.ar); } + + pla = () => { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.ar = this.pullByte()); } + + phx = () => { this.readByte(this.pc); this.pushByte(this.xr); } + + plx = () => { this.readByte(this.pc); this.readByte(0x0100 | this.sp);this.testNZ(this.xr = this.pullByte()); } + + phy = () => { this.readByte(this.pc); this.pushByte(this.yr); } + + ply = () => { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.testNZ(this.yr = this.pullByte()); } + + php = () => { this.readByte(this.pc); this.pushByte(this.sr | flags.B); } + + plp = () => { this.readByte(this.pc); this.readByte(0x0100 | this.sp); this.sr = (this.pullByte() & ~flags.B) | 0x20; } + + /* Jump */ + jmp = (readAddrFn: ReadAddrFn) => { + this.pc = readAddrFn(); + } + + /* Jump Subroutine */ + jsr = () => { + const lsb = this.readBytePC(); + this.readByte(0x0100 | this.sp); + this.pushWord(this.pc); + const msb = this.readBytePC(); + this.pc = (msb << 8 | lsb) & 0xffff; + } + + /* Return from Subroutine */ + rts = () => { + this.readByte(this.pc); + this.readByte(0x0100 | this.sp); + const addr = this.pullWordRaw(); + this.readByte(addr); + this.pc = (addr + 1) & 0xffff; + } + + /* Return from Interrupt */ + rti = () => { + this.readByte(this.pc); + this.readByte(0x0100 | this.sp); + this.sr = this.pullByte() & ~flags.B; + this.pc = this.pullWordRaw(); + } + + /* Set and Clear */ + set = (flag: flag) => { + this.readByte(this.pc); + this.sr |= flag; + } + + clr = (flag: flag) => { + this.readByte(this.pc); + this.sr &= ~flag; + } + + /* No-Op */ + nop = (readAddrFn: ReadAddrFn) => { + this.readByte(this.pc); + readAddrFn(); + } + + private unknown(b: byte) { + let unk: Instruction; + + if (this.is65C02) { + unk = { + name: 'NOP', + op: this.nop, + modeFn: this.implied, + mode: 'implied', + }; + } else { + unk = { + name: '???', + op: function() { + debug('Unknown OpCode: ' + toHex(b) + + ' at ' + toHex(this.pc - 1, 4)); + }, + modeFn: this.implied, + mode: 'implied' + }; + } + this.ops[b] = unk; + return unk; + } + + private dumpArgs(addr: word, m: Mode, symbols: symbols) { + function toHexOrSymbol(v: word, n?: number) { + if (symbols && symbols[v]) { + return symbols[v]; + } else { + return '$' + toHex(v, n); + } + } + + let off, val; + let result = ''; + switch (m) { + case 'implied': + break; + case 'immediate': + result = '#' + toHexOrSymbol(this.readByteDebug(addr)); + break; + case 'absolute': + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4); + break; + case 'zeroPage': + result = '' + toHexOrSymbol(this.readByteDebug(addr)); + break; + case 'relative': + { + let off = this.readByteDebug(addr); + if (off > 127) { + off -= 256; + } + addr += off + 1; + result = '' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + } + break; + case 'absoluteX': + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',X'; + break; + case 'absoluteY': + result = '' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',Y'; + break; + case 'zeroPageX': + result = '' + toHexOrSymbol(this.readByteDebug(addr)) + ',X'; + break; + case 'zeroPageY': + result = '' + toHexOrSymbol(this.readByteDebug(addr)) + ',Y'; + break; + case 'absoluteIndirect': + result = '(' + toHexOrSymbol(this.readWordDebug(addr), 4) + ')'; + break; + case 'zeroPageXIndirect': + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + ',X)'; + break; + case 'zeroPageIndirectY': + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + '),Y'; + break; + case 'accumulator': + result = 'A'; + break; + case 'zeroPageIndirect': + result = '(' + toHexOrSymbol(this.readByteDebug(addr)) + ')'; + break; + case 'absoluteXIndirect': + result = '(' + toHexOrSymbol(this.readWordDebug(addr), 4) + ',X)'; + break; + case 'zeroPage_relative': + val = this.readByteDebug(addr); + off = this.readByteDebug(addr + 1); + if (off > 127) { + off -= 256; + } + addr += off + 2; + result = '' + toHexOrSymbol(val) + ',' + toHexOrSymbol(addr, 4) + ' (' + off + ')'; + break; + default: + break; + } + return result; + } + + public step(cb: callback) { + this.sync = true; + const op = this.opary[this.readBytePC()]; + this.sync = false; + op.op(op.modeFn); + + if (cb) { + cb(this); + } + } + + public stepDebug(n: number, cb: callback) { + for (let idx = 0; idx < n; idx++) { + this.sync = true; + const op = this.opary[this.readBytePC()]; + this.sync = false; + op.op(op.modeFn); + + if (cb) { + cb(this); + } + } + } + + public stepCycles(c: number) { + const end = this.cycles + c; + + while (this.cycles < end) { + this.sync = true; + const op = this.opary[this.readBytePC()]; + this.sync = false; + op.op(op.modeFn); + } + } + + public stepCyclesDebug(c: number, cb: callback): void { + const end = this.cycles + c; + + while (this.cycles < end) { + this.sync = true; + const op = this.opary[this.readBytePC()]; + this.sync = false; + op.op(op.modeFn); + + if (cb) { + cb(this); + } + } + } + + public addPageHandler(pho: (PageHandler | ResettablePageHandler) & (ReadablePage | WriteablePage)) { + for (let idx = pho.start(); idx <= pho.end(); idx++) { + if (isReadablePage(pho)) + this.readPages[idx] = pho; + if (isWriteablePage(pho)) + this.writePages[idx] = pho; + } + if (isResettablePageHandler(pho)) + this.resetHandlers.push(pho); + } + + public reset() { + // cycles = 0; + this.sr = 0x20; + this.sp = 0xff; + this.ar = 0; + this.yr = 0; + this.xr = 0; + this.pc = this.readWord(loc.RESET); + + for (let idx = 0; idx < this.resetHandlers.length; idx++) { + this.resetHandlers[idx].reset(); + } + } + + /* IRQ - Interrupt Request */ + public irq() { + if ((this.sr & flags.I) === 0) { + this.pushWord(this.pc); + this.pushByte(this.sr & ~flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.BRK); + } + } + + /* NMI Non-maskable Interrupt */ + public nmi() { + this.pushWord(this.pc); + this.pushByte(this.sr & ~flags.B); + if (this.is65C02) { + this.setFlag(flags.D, false); + } + this.setFlag(flags.I, true); + this.pc = this.readWord(loc.NMI); + } + + public getPC() { + return this.pc; + } + + public setPC(pc: word) { + this.pc = pc; + } + + public dumpPC(pc: word, symbols: symbols) { + if (pc === undefined) { + pc = this.pc; + } + const b = this.readByte(pc), + op = this.ops[b], + size = sizes[op.mode]; + let result = toHex(pc, 4) + '- '; + + if (symbols) { + if (symbols[pc]) { + result += symbols[pc] + + ' '.substring(symbols[pc].length); + } else { + result += ' '; + } + } + + for (let idx = 0; idx < 4; idx++) { + if (idx < size) { + result += toHex(this.readByte(pc + idx)) + ' '; + } else { + result += ' '; + } + } + + if (op === undefined) + result += '??? (' + toHex(b) + ')'; + else + result += op.name + ' ' + this.dumpArgs(pc + 1, op.mode, symbols); + + return result; + } + + public dumpPage(start?: word, end?: word) { + let result = ''; + if (start === undefined) { + start = this.pc >> 8; + } + if (end === undefined) { + end = start; + } + for (let page = start; page <= end; page++) { + for (let idx = 0; idx < 16; idx++) { + result += toHex(page) + toHex(idx << 4) + ': '; + for (let jdx = 0; jdx < 16; jdx++) { + const b = this.readByteDebug(page * 256 + idx * 16 + jdx); + result += toHex(b) + ' '; + } + result += ' '; + for (let jdx = 0; jdx < 16; jdx++) { + const b = this.readByte(page * 256 + idx * 16 + jdx) & 0x7f; + if (b >= 0x20 && b < 0x7f) { + result += String.fromCharCode(b); + } else { + result += '.'; + } + } + result += '\n'; + } + } + return result; + } + + public list(_pc: word, symbols: symbols) { + if (_pc === undefined) { + _pc = this.pc; + } + const results = []; + for (let jdx = 0; jdx < 20; jdx++) { + const b = this.readByte(_pc), op = this.ops[b]; + results.push(this.dumpPC(_pc, symbols)); + _pc += sizes[op.mode]; + } + return results; + } + + public sync_() { + return this.sync; + } + + public cycles_() { + return this.cycles; + } + + public registers() { + return [this.pc,this.ar,this.xr,this.yr,this.sr,this.sp]; + } + + public getState(): CpuState { + return { + a: this.ar, + x: this.xr, + y: this.yr, + s: this.sr, + pc: this.pc, + sp: this.sp, + cycles: this.cycles + }; + } + + public setState(state: CpuState) { + this.ar = state.a; + this.xr = state.x; + this.yr = state.y; + this.sr = state.s; + this.pc = state.pc; + this.sp = state.sp; + this.cycles = state.cycles; + } + + public dumpRegisters() { + return toHex(this.pc, 4) + + '- A=' + toHex(this.ar) + + ' X=' + toHex(this.xr) + + ' Y=' + toHex(this.yr) + + ' P=' + toHex(this.sr) + + ' S=' + toHex(this.sp) + + ' ' + + ((this.sr & flags.N) ? 'N' : '-') + + ((this.sr & flags.V) ? 'V' : '-') + + '-' + + ((this.sr & flags.B) ? 'B' : '-') + + ((this.sr & flags.D) ? 'D' : '-') + + ((this.sr & flags.I) ? 'I' : '-') + + ((this.sr & flags.Z) ? 'Z' : '-') + + ((this.sr & flags.C) ? 'C' : '-'); + } + + public read(page: byte, off: byte): byte { + return this.readPages[page].read(page, off); + } + + public write(page: byte, off: byte, val: byte) { + this.writePages[page].write(page, off, val); + } + + OPS_6502: Instructions = { + // LDA + 0xa9: { name: 'LDA', op: this.lda, modeFn: this.readImmediate, mode: 'immediate' }, + 0xa5: { name: 'LDA', op: this.lda, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0xb5: { name: 'LDA', op: this.lda, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0xad: { name: 'LDA', op: this.lda, modeFn: this.readAbsolute, mode: 'absolute' }, + 0xbd: { name: 'LDA', op: this.lda, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + 0xb9: { name: 'LDA', op: this.lda, modeFn: this.readAbsoluteY, mode: 'absoluteY' }, + 0xa1: { name: 'LDA', op: this.lda, modeFn: this.readZeroPageXIndirect, mode: 'zeroPageXIndirect' }, + 0xb1: { name: 'LDA', op: this.lda, modeFn: this.readZeroPageIndirectY, mode: 'zeroPageIndirectY' }, + + // LDX + 0xa2: { name: 'LDX', op: this.ldx, modeFn: this.readImmediate, mode: 'immediate' }, + 0xa6: { name: 'LDX', op: this.ldx, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0xb6: { name: 'LDX', op: this.ldx, modeFn: this.readZeroPageY, mode: 'zeroPageY' }, + 0xae: { name: 'LDX', op: this.ldx, modeFn: this.readAbsolute, mode: 'absolute' }, + 0xbe: { name: 'LDX', op: this.ldx, modeFn: this.readAbsoluteY, mode: 'absoluteY' }, + + // LDY + 0xa0: { name: 'LDY', op: this.ldy, modeFn: this.readImmediate, mode: 'immediate' }, + 0xa4: { name: 'LDY', op: this.ldy, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0xb4: { name: 'LDY', op: this.ldy, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0xac: { name: 'LDY', op: this.ldy, modeFn: this.readAbsolute, mode: 'absolute' }, + 0xbc: { name: 'LDY', op: this.ldy, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + + // STA + 0x85: { name: 'STA', op: this.sta, modeFn: this.writeZeroPage, mode: 'zeroPage' }, + 0x95: { name: 'STA', op: this.sta, modeFn: this.writeZeroPageX, mode: 'zeroPageX' }, + 0x8d: { name: 'STA', op: this.sta, modeFn: this.writeAbsolute, mode: 'absolute' }, + 0x9d: { name: 'STA', op: this.sta, modeFn: this.writeAbsoluteX, mode: 'absoluteX' }, + 0x99: { name: 'STA', op: this.sta, modeFn: this.writeAbsoluteY, mode: 'absoluteY' }, + 0x81: { name: 'STA', op: this.sta, modeFn: this.writeZeroPageXIndirect, mode: 'zeroPageXIndirect' }, + 0x91: { name: 'STA', op: this.sta, modeFn: this.writeZeroPageIndirectY, mode: 'zeroPageIndirectY' }, + + // STX + 0x86: { name: 'STX', op: this.stx, modeFn: this.writeZeroPage, mode: 'zeroPage' }, + 0x96: { name: 'STX', op: this.stx, modeFn: this.writeZeroPageY, mode: 'zeroPageY' }, + 0x8e: { name: 'STX', op: this.stx, modeFn: this.writeAbsolute, mode: 'absolute' }, + + // STY + 0x84: { name: 'STY', op: this.sty, modeFn: this.writeZeroPage, mode: 'zeroPage' }, + 0x94: { name: 'STY', op: this.sty, modeFn: this.writeZeroPageX, mode: 'zeroPageX' }, + 0x8c: { name: 'STY', op: this.sty, modeFn: this.writeAbsolute, mode: 'absolute' }, + + // ADC + 0x69: { name: 'ADC', op: this.adc, modeFn: this.readImmediate, mode: 'immediate' }, + 0x65: { name: 'ADC', op: this.adc, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0x75: { name: 'ADC', op: this.adc, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0x6D: { name: 'ADC', op: this.adc, modeFn: this.readAbsolute, mode: 'absolute' }, + 0x7D: { name: 'ADC', op: this.adc, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + 0x79: { name: 'ADC', op: this.adc, modeFn: this.readAbsoluteY, mode: 'absoluteY' }, + 0x61: { name: 'ADC', op: this.adc, modeFn: this.readZeroPageXIndirect, mode: 'zeroPageXIndirect' }, + 0x71: { name: 'ADC', op: this.adc, modeFn: this.readZeroPageIndirectY, mode: 'zeroPageIndirectY' }, + + // SBC + 0xe9: { name: 'SBC', op: this.sbc, modeFn: this.readImmediate, mode: 'immediate' }, + 0xe5: { name: 'SBC', op: this.sbc, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0xf5: { name: 'SBC', op: this.sbc, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0xeD: { name: 'SBC', op: this.sbc, modeFn: this.readAbsolute, mode: 'absolute' }, + 0xfD: { name: 'SBC', op: this.sbc, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + 0xf9: { name: 'SBC', op: this.sbc, modeFn: this.readAbsoluteY, mode: 'absoluteY' }, + 0xe1: { name: 'SBC', op: this.sbc, modeFn: this.readZeroPageXIndirect, mode: 'zeroPageXIndirect' }, + 0xf1: { name: 'SBC', op: this.sbc, modeFn: this.readZeroPageIndirectY, mode: 'zeroPageIndirectY' }, + + // INC + 0xe6: { name: 'INC', op: this.inc, modeFn: this.readAddrZeroPage, mode: 'zeroPage' }, + 0xf6: { name: 'INC', op: this.inc, modeFn: this.readAddrZeroPageX, mode: 'zeroPageX' }, + 0xee: { name: 'INC', op: this.inc, modeFn: this.readAddrAbsolute, mode: 'absolute' }, + 0xfe: { name: 'INC', op: this.inc, modeFn: this.readAddrAbsoluteX, mode: 'absoluteX' }, + + // INX + 0xe8: { name: 'INX', op: this.inx, modeFn: this.implied, mode: 'implied' }, + + // INY + 0xc8: { name: 'INY', op: this.iny, modeFn: this.implied, mode: 'implied' }, + + // DEC + 0xc6: { name: 'DEC', op: this.dec, modeFn: this.readAddrZeroPage, mode: 'zeroPage' }, + 0xd6: { name: 'DEC', op: this.dec, modeFn: this.readAddrZeroPageX, mode: 'zeroPageX' }, + 0xce: { name: 'DEC', op: this.dec, modeFn: this.readAddrAbsolute, mode: 'absolute' }, + 0xde: { name: 'DEC', op: this.dec, modeFn: this.readAddrAbsoluteX, mode: 'absoluteX' }, + + // DEX + 0xca: { name: 'DEX', op: this.dex, modeFn: this.implied, mode: 'implied' }, + + // DEY + 0x88: { name: 'DEY', op: this.dey, modeFn: this.implied, mode: 'implied' }, + + // ASL + 0x0A: { name: 'ASL', op: this.aslA, modeFn: this.implied, mode: 'accumulator' }, + 0x06: { name: 'ASL', op: this.asl, modeFn: this.readAddrZeroPage, mode: 'zeroPage' }, + 0x16: { name: 'ASL', op: this.asl, modeFn: this.readAddrZeroPageX, mode: 'zeroPageX' }, + 0x0E: { name: 'ASL', op: this.asl, modeFn: this.readAddrAbsolute, mode: 'absolute' }, + 0x1E: { name: 'ASL', op: this.asl, modeFn: this.readAddrAbsoluteX, mode: 'absoluteX' }, + + // LSR + 0x4A: { name: 'LSR', op: this.lsrA, modeFn: this.implied, mode: 'accumulator' }, + 0x46: { name: 'LSR', op: this.lsr, modeFn: this.readAddrZeroPage, mode: 'zeroPage' }, + 0x56: { name: 'LSR', op: this.lsr, modeFn: this.readAddrZeroPageX, mode: 'zeroPageX' }, + 0x4E: { name: 'LSR', op: this.lsr, modeFn: this.readAddrAbsolute, mode: 'absolute' }, + 0x5E: { name: 'LSR', op: this.lsr, modeFn: this.readAddrAbsoluteX, mode: 'absoluteX' }, + + // ROL + 0x2A: { name: 'ROL', op: this.rolA, modeFn: this.implied, mode: 'accumulator' }, + 0x26: { name: 'ROL', op: this.rol, modeFn: this.readAddrZeroPage, mode: 'zeroPage' }, + 0x36: { name: 'ROL', op: this.rol, modeFn: this.readAddrZeroPageX, mode: 'zeroPageX' }, + 0x2E: { name: 'ROL', op: this.rol, modeFn: this.readAddrAbsolute, mode: 'absolute' }, + 0x3E: { name: 'ROL', op: this.rol, modeFn: this.readAddrAbsoluteX, mode: 'absoluteX' }, + + // ROR + 0x6A: { name: 'ROR', op: this.rorA, modeFn: this.implied, mode: 'accumulator' }, + 0x66: { name: 'ROR', op: this.ror, modeFn: this.readAddrZeroPage, mode: 'zeroPage' }, + 0x76: { name: 'ROR', op: this.ror, modeFn: this.readAddrZeroPageX, mode: 'zeroPageX' }, + 0x6E: { name: 'ROR', op: this.ror, modeFn: this.readAddrAbsolute, mode: 'absolute' }, + 0x7E: { name: 'ROR', op: this.ror, modeFn: this.readAddrAbsoluteX, mode: 'absoluteX' }, + + // AND + 0x29: { name: 'AND', op: this.and, modeFn: this.readImmediate, mode: 'immediate' }, + 0x25: { name: 'AND', op: this.and, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0x35: { name: 'AND', op: this.and, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0x2D: { name: 'AND', op: this.and, modeFn: this.readAbsolute, mode: 'absolute' }, + 0x3D: { name: 'AND', op: this.and, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + 0x39: { name: 'AND', op: this.and, modeFn: this.readAbsoluteY, mode: 'absoluteY' }, + 0x21: { name: 'AND', op: this.and, modeFn: this.readZeroPageXIndirect, mode: 'zeroPageXIndirect' }, + 0x31: { name: 'AND', op: this.and, modeFn: this.readZeroPageIndirectY, mode: 'zeroPageIndirectY' }, + + // ORA + 0x09: { name: 'ORA', op: this.ora, modeFn: this.readImmediate, mode: 'immediate' }, + 0x05: { name: 'ORA', op: this.ora, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0x15: { name: 'ORA', op: this.ora, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0x0D: { name: 'ORA', op: this.ora, modeFn: this.readAbsolute, mode: 'absolute' }, + 0x1D: { name: 'ORA', op: this.ora, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + 0x19: { name: 'ORA', op: this.ora, modeFn: this.readAbsoluteY, mode: 'absoluteY' }, + 0x01: { name: 'ORA', op: this.ora, modeFn: this.readZeroPageXIndirect, mode: 'zeroPageXIndirect' }, + 0x11: { name: 'ORA', op: this.ora, modeFn: this.readZeroPageIndirectY, mode: 'zeroPageIndirectY' }, + + // EOR + 0x49: { name: 'EOR', op: this.eor, modeFn: this.readImmediate, mode: 'immediate' }, + 0x45: { name: 'EOR', op: this.eor, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0x55: { name: 'EOR', op: this.eor, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0x4D: { name: 'EOR', op: this.eor, modeFn: this.readAbsolute, mode: 'absolute' }, + 0x5D: { name: 'EOR', op: this.eor, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + 0x59: { name: 'EOR', op: this.eor, modeFn: this.readAbsoluteY, mode: 'absoluteY' }, + 0x41: { name: 'EOR', op: this.eor, modeFn: this.readZeroPageXIndirect, mode: 'zeroPageXIndirect' }, + 0x51: { name: 'EOR', op: this.eor, modeFn: this.readZeroPageIndirectY, mode: 'zeroPageIndirectY' }, + + // CMP + 0xc9: { name: 'CMP', op: this.cmp, modeFn: this.readImmediate, mode: 'immediate' }, + 0xc5: { name: 'CMP', op: this.cmp, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0xd5: { name: 'CMP', op: this.cmp, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0xcD: { name: 'CMP', op: this.cmp, modeFn: this.readAbsolute, mode: 'absolute' }, + 0xdD: { name: 'CMP', op: this.cmp, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + 0xd9: { name: 'CMP', op: this.cmp, modeFn: this.readAbsoluteY, mode: 'absoluteY' }, + 0xc1: { name: 'CMP', op: this.cmp, modeFn: this.readZeroPageXIndirect, mode: 'zeroPageXIndirect' }, + 0xd1: { name: 'CMP', op: this.cmp, modeFn: this.readZeroPageIndirectY, mode: 'zeroPageIndirectY' }, + + // CPX + 0xE0: { name: 'CPX', op: this.cpx, modeFn: this.readImmediate, mode: 'immediate' }, + 0xE4: { name: 'CPX', op: this.cpx, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0xEC: { name: 'CPX', op: this.cpx, modeFn: this.readAbsolute, mode: 'absolute' }, + + // CPY + 0xC0: { name: 'CPY', op: this.cpy, modeFn: this.readImmediate, mode: 'immediate' }, + 0xC4: { name: 'CPY', op: this.cpy, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0xCC: { name: 'CPY', op: this.cpy, modeFn: this.readAbsolute, mode: 'absolute' }, + + // BIT + 0x24: { name: 'BIT', op: this.bit, modeFn: this.readZeroPage, mode: 'zeroPage' }, + 0x2C: { name: 'BIT', op: this.bit, modeFn: this.readAbsolute, mode: 'absolute' }, + + // BCC + 0x90: { name: 'BCC', op: this.brc, modeFn: flags.C, mode: 'relative' }, + + // BCS + 0xB0: { name: 'BCS', op: this.brs, modeFn: flags.C, mode: 'relative' }, + + // BEQ + 0xF0: { name: 'BEQ', op: this.brs, modeFn: flags.Z, mode: 'relative' }, + + // BMI + 0x30: { name: 'BMI', op: this.brs, modeFn: flags.N, mode: 'relative' }, + + // BNE + 0xD0: { name: 'BNE', op: this.brc, modeFn: flags.Z, mode: 'relative' }, + + // BPL + 0x10: { name: 'BPL', op: this.brc, modeFn: flags.N, mode: 'relative' }, + + // BVC + 0x50: { name: 'BVC', op: this.brc, modeFn: flags.V, mode: 'relative' }, + + // BVS + 0x70: { name: 'BVS', op: this.brs, modeFn: flags.V, mode: 'relative' }, + + // TAX + 0xAA: { name: 'TAX', op: this.tax, modeFn: this.implied, mode: 'implied' }, + + // TXA + 0x8A: { name: 'TXA', op: this.txa, modeFn: this.implied, mode: 'implied' }, + + // TAY + 0xA8: { name: 'TAY', op: this.tay, modeFn: this.implied, mode: 'implied' }, + + // TYA + 0x98: { name: 'TYA', op: this.tya, modeFn: this.implied, mode: 'implied' }, + + // TSX + 0xBA: { name: 'TSX', op: this.tsx, modeFn: this.implied, mode: 'implied' }, + + // TXS + 0x9A: { name: 'TXS', op: this.txs, modeFn: this.implied, mode: 'implied' }, + + // PHA + 0x48: { name: 'PHA', op: this.pha, modeFn: this.implied, mode: 'implied' }, + + // PLA + 0x68: { name: 'PLA', op: this.pla, modeFn: this.implied, mode: 'implied' }, + + // PHP + 0x08: { name: 'PHP', op: this.php, modeFn: this.implied, mode: 'implied' }, + + // PLP + 0x28: { name: 'PLP', op: this.plp, modeFn: this.implied, mode: 'implied' }, + + // JMP + 0x4C: { + name: 'JMP', op: this.jmp, modeFn: this.readAddrAbsolute, mode: 'absolute' + }, + 0x6C: { + name: 'JMP', op: this.jmp, modeFn: this.readAddrAbsoluteIndirectBug, mode: 'absoluteIndirect' + }, + // JSR + 0x20: { name: 'JSR', op: this.jsr, modeFn: this.readAddrAbsolute, mode: 'absolute' }, + + // RTS + 0x60: { name: 'RTS', op: this.rts, modeFn: this.implied, mode: 'implied' }, + + // RTI + 0x40: { name: 'RTI', op: this.rti, modeFn: this.implied, mode: 'implied' }, + + // SEC + 0x38: { name: 'SEC', op: this.set, modeFn: flags.C, mode: 'implied' }, + + // SED + 0xF8: { name: 'SED', op: this.set, modeFn: flags.D, mode: 'implied' }, + + // SEI + 0x78: { name: 'SEI', op: this.set, modeFn: flags.I, mode: 'implied' }, + + // CLC + 0x18: { name: 'CLC', op: this.clr, modeFn: flags.C, mode: 'implied' }, + + // CLD + 0xD8: { name: 'CLD', op: this.clr, modeFn: flags.D, mode: 'implied' }, + + // CLI + 0x58: { name: 'CLI', op: this.clr, modeFn: flags.I, mode: 'implied' }, + + // CLV + 0xB8: { name: 'CLV', op: this.clr, modeFn: flags.V, mode: 'implied' }, + + // NOP + 0xea: { name: 'NOP', op: this.nop, modeFn: this.implied, mode: 'implied' }, + + // BRK + 0x00: { name: 'BRK', op: this.brk, modeFn: this.readImmediate, mode: 'immediate' } + }; + + /* 65C02 Instructions */ + + OPS_65C02: Instructions = { + // INC / DEC A + 0x1A: { name: 'INC', op: this.incA, modeFn: this.implied, mode: 'accumulator' }, + 0x3A: { name: 'DEC', op: this.decA, modeFn: this.implied, mode: 'accumulator' }, + + // Indirect Zero Page for the masses + 0x12: { name: 'ORA', op: this.ora, modeFn: this.readZeroPageIndirect, mode: 'zeroPageIndirect' }, + 0x32: { name: 'AND', op: this.and, modeFn: this.readZeroPageIndirect, mode: 'zeroPageIndirect' }, + 0x52: { name: 'EOR', op: this.eor, modeFn: this.readZeroPageIndirect, mode: 'zeroPageIndirect' }, + 0x72: { name: 'ADC', op: this.adc, modeFn: this.readZeroPageIndirect, mode: 'zeroPageIndirect' }, + 0x92: { name: 'STA', op: this.sta, modeFn: this.writeZeroPageIndirect, mode: 'zeroPageIndirect' }, + 0xB2: { name: 'LDA', op: this.lda, modeFn: this.readZeroPageIndirect, mode: 'zeroPageIndirect' }, + 0xD2: { name: 'CMP', op: this.cmp, modeFn: this.readZeroPageIndirect, mode: 'zeroPageIndirect' }, + 0xF2: { name: 'SBC', op: this.sbc, modeFn: this.readZeroPageIndirect, mode: 'zeroPageIndirect' }, + + // Better BIT + 0x34: { name: 'BIT', op: this.bit, modeFn: this.readZeroPageX, mode: 'zeroPageX' }, + 0x3C: { name: 'BIT', op: this.bit, modeFn: this.readAbsoluteX, mode: 'absoluteX' }, + 0x89: { name: 'BIT', op: this.bitI, modeFn: this.readImmediate, mode: 'immediate' }, + + // JMP absolute indirect indexed + 0x6C: { + name: 'JMP', op: this.jmp, modeFn: this.readAddrAbsoluteIndirect, mode: 'absoluteIndirect' + }, + 0x7C: { + name: 'JMP', op: this.jmp, modeFn: this.readAddrAbsoluteXIndirect, mode: 'absoluteXIndirect' + }, + + // BBR/BBS + 0x0F: { name: 'BBR0', op: this.bbr, modeFn: 0, mode: 'zeroPage_relative' }, + 0x1F: { name: 'BBR1', op: this.bbr, modeFn: 1, mode: 'zeroPage_relative' }, + 0x2F: { name: 'BBR2', op: this.bbr, modeFn: 2, mode: 'zeroPage_relative' }, + 0x3F: { name: 'BBR3', op: this.bbr, modeFn: 3, mode: 'zeroPage_relative' }, + 0x4F: { name: 'BBR4', op: this.bbr, modeFn: 4, mode: 'zeroPage_relative' }, + 0x5F: { name: 'BBR5', op: this.bbr, modeFn: 5, mode: 'zeroPage_relative' }, + 0x6F: { name: 'BBR6', op: this.bbr, modeFn: 6, mode: 'zeroPage_relative' }, + 0x7F: { name: 'BBR7', op: this.bbr, modeFn: 7, mode: 'zeroPage_relative' }, + + 0x8F: { name: 'BBS0', op: this.bbs, modeFn: 0, mode: 'zeroPage_relative' }, + 0x9F: { name: 'BBS1', op: this.bbs, modeFn: 1, mode: 'zeroPage_relative' }, + 0xAF: { name: 'BBS2', op: this.bbs, modeFn: 2, mode: 'zeroPage_relative' }, + 0xBF: { name: 'BBS3', op: this.bbs, modeFn: 3, mode: 'zeroPage_relative' }, + 0xCF: { name: 'BBS4', op: this.bbs, modeFn: 4, mode: 'zeroPage_relative' }, + 0xDF: { name: 'BBS5', op: this.bbs, modeFn: 5, mode: 'zeroPage_relative' }, + 0xEF: { name: 'BBS6', op: this.bbs, modeFn: 6, mode: 'zeroPage_relative' }, + 0xFF: { name: 'BBS7', op: this.bbs, modeFn: 7, mode: 'zeroPage_relative' }, + + // BRA + 0x80: { name: 'BRA', op: this.brc, modeFn: 0, mode: 'relative' }, + + // NOP + 0x02: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0x22: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0x42: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0x44: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0x54: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0x62: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0x82: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0xC2: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0xD4: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0xE2: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0xF4: { name: 'NOP', op: this.nop, modeFn: this.readImmediate, mode: 'immediate' }, + 0x5C: { name: 'NOP', op: this.nop, modeFn: this.readAbsolute, mode: 'absolute' }, + 0xDC: { name: 'NOP', op: this.nop, modeFn: this.readAbsolute, mode: 'absolute' }, + 0xFC: { name: 'NOP', op: this.nop, modeFn: this.readAbsolute, mode: 'absolute' }, + + // PHX + 0xDA: { name: 'PHX', op: this.phx, modeFn: this.implied, mode: 'implied' }, + + // PHY + 0x5A: { name: 'PHY', op: this.phy, modeFn: this.implied, mode: 'implied' }, + + // PLX + 0xFA: { name: 'PLX', op: this.plx, modeFn: this.implied, mode: 'implied' }, + + // PLY + 0x7A: { name: 'PLY', op: this.ply, modeFn: this.implied, mode: 'implied' }, + + // RMB/SMB + + 0x07: { name: 'RMB0', op: this.rmb, modeFn: 0, mode: 'zeroPage' }, + 0x17: { name: 'RMB1', op: this.rmb, modeFn: 1, mode: 'zeroPage' }, + 0x27: { name: 'RMB2', op: this.rmb, modeFn: 2, mode: 'zeroPage' }, + 0x37: { name: 'RMB3', op: this.rmb, modeFn: 3, mode: 'zeroPage' }, + 0x47: { name: 'RMB4', op: this.rmb, modeFn: 4, mode: 'zeroPage' }, + 0x57: { name: 'RMB5', op: this.rmb, modeFn: 5, mode: 'zeroPage' }, + 0x67: { name: 'RMB6', op: this.rmb, modeFn: 6, mode: 'zeroPage' }, + 0x77: { name: 'RMB7', op: this.rmb, modeFn: 7, mode: 'zeroPage' }, + + 0x87: { name: 'SMB0', op: this.smb, modeFn: 0, mode: 'zeroPage' }, + 0x97: { name: 'SMB1', op: this.smb, modeFn: 1, mode: 'zeroPage' }, + 0xA7: { name: 'SMB2', op: this.smb, modeFn: 2, mode: 'zeroPage' }, + 0xB7: { name: 'SMB3', op: this.smb, modeFn: 3, mode: 'zeroPage' }, + 0xC7: { name: 'SMB4', op: this.smb, modeFn: 4, mode: 'zeroPage' }, + 0xD7: { name: 'SMB5', op: this.smb, modeFn: 5, mode: 'zeroPage' }, + 0xE7: { name: 'SMB6', op: this.smb, modeFn: 6, mode: 'zeroPage' }, + 0xF7: { name: 'SMB7', op: this.smb, modeFn: 7, mode: 'zeroPage' }, + + // STZ + 0x64: { name: 'STZ', op: this.stz, modeFn: this.writeZeroPage, mode: 'zeroPage' }, + 0x74: { name: 'STZ', op: this.stz, modeFn: this.writeZeroPageX, mode: 'zeroPageX' }, + 0x9C: { name: 'STZ', op: this.stz, modeFn: this.writeAbsolute, mode: 'absolute' }, + 0x9E: { name: 'STZ', op: this.stz, modeFn: this.writeAbsoluteX, mode: 'absoluteX' }, + + // TRB + 0x14: { name: 'TRB', op: this.trb, modeFn: this.readAddrZeroPage, mode: 'zeroPage' }, + 0x1C: { name: 'TRB', op: this.trb, modeFn: this.readAddrAbsolute, mode: 'absolute' }, + + // TSB + 0x04: { name: 'TSB', op: this.tsb, modeFn: this.readAddrZeroPage, mode: 'zeroPage' }, + 0x0C: { name: 'TSB', op: this.tsb, modeFn: this.readAddrAbsolute, mode: 'absolute' } + } +} diff --git a/test/tscpu6502v5.spec.js b/test/tscpu6502v6.spec.js similarity index 99% rename from test/tscpu6502v5.spec.js rename to test/tscpu6502v6.spec.js index 1ca8ad6c..13e5bbcb 100644 --- a/test/tscpu6502v5.spec.js +++ b/test/tscpu6502v6.spec.js @@ -1,4 +1,4 @@ -import CPU6502 from './perf/impl/tscpu6502v5'; +import CPU6502 from './perf/impl/tscpu6502v6'; function assertByte(b) { expect(b <= 0xFF).toEqual(true);