From 174fe17e896ca7539ed9dfb34b65c31bee2b1e11 Mon Sep 17 00:00:00 2001 From: Niklas Gollenstede Date: Fri, 31 Oct 2025 22:37:36 +0100 Subject: [PATCH] Handout --- .clang-format | 4 + .clang-format-ignore | 2 + .clang-tidy | 6 + .envrc | 1 + .gitignore | 2 + CPPLINT.cfg | 16 + LICENSE | 14 + Makefile | 31 + README.md | 42 + kernel/CPPLINT.cfg | 3 + kernel/Makefile | 36 + kernel/arch/acpi.cc | 146 + kernel/arch/acpi.h | 270 + kernel/arch/apic.cc | 161 + kernel/arch/apic.h | 82 + kernel/arch/cache.h | 22 + kernel/arch/cga.cc | 78 + kernel/arch/cga.h | 135 + kernel/arch/cmos.cc | 61 + kernel/arch/cmos.h | 46 + kernel/arch/context.asm | 53 + kernel/arch/context.cc | 39 + kernel/arch/context.h | 116 + kernel/arch/core.cc | 73 + kernel/arch/core.h | 118 + kernel/arch/core_cr.h | 83 + kernel/arch/core_interrupt.h | 146 + kernel/arch/core_msr.h | 101 + kernel/arch/core_ring.cc | 17 + kernel/arch/core_ring.h | 31 + kernel/arch/cpuid.h | 205 + kernel/arch/gdt.cc | 36 + kernel/arch/gdt.h | 203 + kernel/arch/idt.cc | 36 + kernel/arch/idt.h | 233 + kernel/arch/ioapic.cc | 123 + kernel/arch/ioapic.h | 76 + kernel/arch/ioapic_registers.h | 228 + kernel/arch/ioport.h | 63 + kernel/arch/lapic.cc | 191 + kernel/arch/lapic.h | 194 + kernel/arch/lapic_ipi.cc | 245 + kernel/arch/lapic_registers.h | 61 + kernel/arch/lapic_timer.cc | 177 + kernel/arch/pic.cc | 65 + kernel/arch/pic.h | 18 + kernel/arch/pit.cc | 226 + kernel/arch/pit.h | 80 + kernel/arch/serial.cc | 55 + kernel/arch/serial.h | 196 + kernel/arch/system.cc | 16 + kernel/arch/system.h | 15 + kernel/arch/textwindow.cc | 129 + kernel/arch/textwindow.h | 168 + kernel/arch/tss.h | 49 + kernel/assets/cat.h | 4420 +++++++++++++ kernel/assets/cat.png | Bin 0 -> 52976 bytes kernel/assets/demon.h | 10984 +++++++++++++++++++++++++++++++ kernel/assets/demon.png | Bin 0 -> 131771 bytes kernel/assets/ibr.h | 3175 +++++++++ kernel/assets/osg.h | 3175 +++++++++ kernel/assets/pc.h | 101 + kernel/assets/pc.png | Bin 0 -> 1176 bytes kernel/boot/longmode.asm | 250 + kernel/boot/multiboot/config.inc | 22 + kernel/boot/multiboot/data.cc | 160 + kernel/boot/multiboot/data.h | 229 + kernel/boot/multiboot/header.asm | 33 + kernel/boot/startup.asm | 78 + kernel/boot/startup.cc | 49 + kernel/boot/startup.h | 35 + kernel/compiler/libc.cc | 46 + kernel/compiler/libc.h | 23 + kernel/compiler/libcxx.cc | 33 + kernel/compiler/sections.ld | 106 + kernel/debug/assert.cc | 11 + kernel/debug/assert.h | 74 + kernel/debug/copystream.h | 44 + kernel/debug/kernelpanic.h | 27 + kernel/debug/nullstream.cc | 4 + kernel/debug/nullstream.h | 45 + kernel/debug/output.h | 69 + kernel/device/graphics.cc | 189 + kernel/device/graphics.h | 284 + kernel/device/graphicsstream.cc | 131 + kernel/device/graphicsstream.h | 135 + kernel/device/keydecoder.cc | 131 + kernel/device/keydecoder.h | 40 + kernel/device/ps2controller.cc | 169 + kernel/device/ps2controller.h | 150 + kernel/device/serialstream.cc | 37 + kernel/device/serialstream.h | 138 + kernel/device/textstream.cc | 10 + kernel/device/textstream.h | 45 + kernel/graphics/fonts/CPPLINT.cfg | 1 + kernel/graphics/fonts/font.cc | 44 + kernel/graphics/fonts/font.h | 73 + kernel/graphics/fonts/font_10x18.h | 5130 +++++++++++++++ kernel/graphics/fonts/font_6x10.h | 3077 +++++++++ kernel/graphics/fonts/font_6x11.h | 3339 ++++++++++ kernel/graphics/fonts/font_7x14.h | 4106 ++++++++++++ kernel/graphics/fonts/font_8x16.h | 4618 +++++++++++++ kernel/graphics/fonts/font_8x8.h | 2570 ++++++++ kernel/graphics/fonts/font_acorn_8x8.h | 260 + kernel/graphics/fonts/font_mini_4x6.h | 2094 ++++++ kernel/graphics/fonts/font_pearl_8x8.h | 2575 ++++++++ kernel/graphics/fonts/font_sun_12x22.h | 6204 +++++++++++++++++ kernel/graphics/fonts/font_sun_8x16.h | 517 ++ kernel/graphics/fonts/font_ter_16x32.h | 1542 +++++ kernel/graphics/framebuffer.h | 317 + kernel/graphics/primitives.h | 168 + kernel/graphics/printer.cc | 40 + kernel/graphics/printer.h | 688 ++ kernel/interrupt/epilogues.cc | 20 + kernel/interrupt/epilogues.h | 42 + kernel/interrupt/guard.cc | 114 + kernel/interrupt/guard.h | 132 + kernel/interrupt/handlers.asm | 39 + kernel/interrupt/handlers.cc | 134 + kernel/interrupt/handlers.h | 19 + kernel/main.cc | 79 + kernel/memory/config.h | 20 + kernel/memory/page.h | 55 + kernel/memory/pagefault.cc | 49 + kernel/memory/pagefault.h | 12 + kernel/object/bbuffer.h | 62 + kernel/object/key.cc | 121 + kernel/object/key.h | 163 + kernel/object/outputstream.cc | 180 + kernel/object/outputstream.h | 209 + kernel/object/queue.h | 271 + kernel/object/stringbuffer.cc | 11 + kernel/object/stringbuffer.h | 75 + kernel/sync/bellringer.cc | 67 + kernel/sync/bellringer.h | 79 + kernel/sync/message.h | 44 + kernel/sync/semaphore.cc | 22 + kernel/sync/semaphore.h | 53 + kernel/syscall/handler.asm | 41 + kernel/syscall/handler.cc | 56 + kernel/syscall/handler.h | 11 + kernel/syscall/skeleton.cc | 71 + kernel/syscall/skeleton.h | 28 + kernel/syscall/stub.asm | 10 + kernel/syscall/stub.h | 24 + kernel/thread/dispatcher.cc | 26 + kernel/thread/dispatcher.h | 53 + kernel/thread/idlethread.cc | 31 + kernel/thread/idlethread.h | 28 + kernel/thread/scheduler.cc | 61 + kernel/thread/scheduler.h | 135 + kernel/thread/thread.cc | 36 + kernel/thread/thread.h | 102 + kernel/types.h | 67 + kernel/user/app1/appl.cc | 42 + kernel/user/app1/appl.h | 32 + kernel/user/app2/kappl.cc | 48 + kernel/user/app2/kappl.h | 26 + kernel/user/loader.cc | 1 + kernel/utils/alloc.cc | 15 + kernel/utils/alloc.h | 36 + kernel/utils/math.h | 27 + kernel/utils/png.cc | 1215 ++++ kernel/utils/png.h | 222 + kernel/utils/random.cc | 42 + kernel/utils/random.h | 51 + kernel/utils/size.h | 17 + kernel/utils/sort.h | 30 + kernel/utils/string.cc | 117 + kernel/utils/string.h | 108 + libsys/Makefile | 23 + libsys/iostream.h | 24 + libsys/libc.cc | 1 + libsys/libc.h | 1 + libsys/math.h | 1 + libsys/outputstream.cc | 1 + libsys/outputstream.h | 1 + libsys/rand.cc | 68 + libsys/rand.h | 9 + libsys/string.cc | 1 + libsys/string.h | 1 + libsys/stringbuffer.cc | 1 + libsys/stringbuffer.h | 1 + libsys/stub.asm | 1 + libsys/stub.h | 1 + libsys/types.h | 1 + nix-develop.sh | 3 + tools/build.mk | 153 + tools/common.mk | 35 + tools/cpplint.py | 6890 +++++++++++++++++++ tools/image.mk | 108 + tools/linter.mk | 34 + tools/qemu.mk | 114 + tools/remote.mk | 39 + user/Makefile | 20 + utils/flake.lock | 43 + utils/flake.nix | 64 + 197 files changed, 79558 insertions(+) create mode 100644 .clang-format create mode 100644 .clang-format-ignore create mode 100644 .clang-tidy create mode 100644 .envrc create mode 100644 .gitignore create mode 100644 CPPLINT.cfg create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 README.md create mode 100644 kernel/CPPLINT.cfg create mode 100644 kernel/Makefile create mode 100644 kernel/arch/acpi.cc create mode 100644 kernel/arch/acpi.h create mode 100644 kernel/arch/apic.cc create mode 100644 kernel/arch/apic.h create mode 100644 kernel/arch/cache.h create mode 100644 kernel/arch/cga.cc create mode 100644 kernel/arch/cga.h create mode 100644 kernel/arch/cmos.cc create mode 100644 kernel/arch/cmos.h create mode 100644 kernel/arch/context.asm create mode 100644 kernel/arch/context.cc create mode 100644 kernel/arch/context.h create mode 100644 kernel/arch/core.cc create mode 100644 kernel/arch/core.h create mode 100644 kernel/arch/core_cr.h create mode 100644 kernel/arch/core_interrupt.h create mode 100644 kernel/arch/core_msr.h create mode 100644 kernel/arch/core_ring.cc create mode 100644 kernel/arch/core_ring.h create mode 100644 kernel/arch/cpuid.h create mode 100644 kernel/arch/gdt.cc create mode 100644 kernel/arch/gdt.h create mode 100644 kernel/arch/idt.cc create mode 100644 kernel/arch/idt.h create mode 100644 kernel/arch/ioapic.cc create mode 100644 kernel/arch/ioapic.h create mode 100644 kernel/arch/ioapic_registers.h create mode 100644 kernel/arch/ioport.h create mode 100644 kernel/arch/lapic.cc create mode 100644 kernel/arch/lapic.h create mode 100644 kernel/arch/lapic_ipi.cc create mode 100644 kernel/arch/lapic_registers.h create mode 100644 kernel/arch/lapic_timer.cc create mode 100644 kernel/arch/pic.cc create mode 100644 kernel/arch/pic.h create mode 100644 kernel/arch/pit.cc create mode 100644 kernel/arch/pit.h create mode 100644 kernel/arch/serial.cc create mode 100644 kernel/arch/serial.h create mode 100644 kernel/arch/system.cc create mode 100644 kernel/arch/system.h create mode 100644 kernel/arch/textwindow.cc create mode 100644 kernel/arch/textwindow.h create mode 100644 kernel/arch/tss.h create mode 100644 kernel/assets/cat.h create mode 100644 kernel/assets/cat.png create mode 100644 kernel/assets/demon.h create mode 100644 kernel/assets/demon.png create mode 100644 kernel/assets/ibr.h create mode 100644 kernel/assets/osg.h create mode 100644 kernel/assets/pc.h create mode 100644 kernel/assets/pc.png create mode 100644 kernel/boot/longmode.asm create mode 100644 kernel/boot/multiboot/config.inc create mode 100644 kernel/boot/multiboot/data.cc create mode 100644 kernel/boot/multiboot/data.h create mode 100644 kernel/boot/multiboot/header.asm create mode 100644 kernel/boot/startup.asm create mode 100644 kernel/boot/startup.cc create mode 100644 kernel/boot/startup.h create mode 100644 kernel/compiler/libc.cc create mode 100644 kernel/compiler/libc.h create mode 100644 kernel/compiler/libcxx.cc create mode 100644 kernel/compiler/sections.ld create mode 100644 kernel/debug/assert.cc create mode 100644 kernel/debug/assert.h create mode 100644 kernel/debug/copystream.h create mode 100644 kernel/debug/kernelpanic.h create mode 100644 kernel/debug/nullstream.cc create mode 100644 kernel/debug/nullstream.h create mode 100644 kernel/debug/output.h create mode 100644 kernel/device/graphics.cc create mode 100644 kernel/device/graphics.h create mode 100644 kernel/device/graphicsstream.cc create mode 100644 kernel/device/graphicsstream.h create mode 100644 kernel/device/keydecoder.cc create mode 100644 kernel/device/keydecoder.h create mode 100644 kernel/device/ps2controller.cc create mode 100644 kernel/device/ps2controller.h create mode 100644 kernel/device/serialstream.cc create mode 100644 kernel/device/serialstream.h create mode 100644 kernel/device/textstream.cc create mode 100644 kernel/device/textstream.h create mode 100644 kernel/graphics/fonts/CPPLINT.cfg create mode 100644 kernel/graphics/fonts/font.cc create mode 100644 kernel/graphics/fonts/font.h create mode 100644 kernel/graphics/fonts/font_10x18.h create mode 100644 kernel/graphics/fonts/font_6x10.h create mode 100644 kernel/graphics/fonts/font_6x11.h create mode 100644 kernel/graphics/fonts/font_7x14.h create mode 100644 kernel/graphics/fonts/font_8x16.h create mode 100644 kernel/graphics/fonts/font_8x8.h create mode 100644 kernel/graphics/fonts/font_acorn_8x8.h create mode 100644 kernel/graphics/fonts/font_mini_4x6.h create mode 100644 kernel/graphics/fonts/font_pearl_8x8.h create mode 100644 kernel/graphics/fonts/font_sun_12x22.h create mode 100644 kernel/graphics/fonts/font_sun_8x16.h create mode 100644 kernel/graphics/fonts/font_ter_16x32.h create mode 100644 kernel/graphics/framebuffer.h create mode 100644 kernel/graphics/primitives.h create mode 100644 kernel/graphics/printer.cc create mode 100644 kernel/graphics/printer.h create mode 100644 kernel/interrupt/epilogues.cc create mode 100644 kernel/interrupt/epilogues.h create mode 100644 kernel/interrupt/guard.cc create mode 100644 kernel/interrupt/guard.h create mode 100644 kernel/interrupt/handlers.asm create mode 100644 kernel/interrupt/handlers.cc create mode 100644 kernel/interrupt/handlers.h create mode 100644 kernel/main.cc create mode 100644 kernel/memory/config.h create mode 100644 kernel/memory/page.h create mode 100644 kernel/memory/pagefault.cc create mode 100644 kernel/memory/pagefault.h create mode 100644 kernel/object/bbuffer.h create mode 100644 kernel/object/key.cc create mode 100644 kernel/object/key.h create mode 100644 kernel/object/outputstream.cc create mode 100644 kernel/object/outputstream.h create mode 100644 kernel/object/queue.h create mode 100644 kernel/object/stringbuffer.cc create mode 100644 kernel/object/stringbuffer.h create mode 100644 kernel/sync/bellringer.cc create mode 100644 kernel/sync/bellringer.h create mode 100644 kernel/sync/message.h create mode 100644 kernel/sync/semaphore.cc create mode 100644 kernel/sync/semaphore.h create mode 100644 kernel/syscall/handler.asm create mode 100644 kernel/syscall/handler.cc create mode 100644 kernel/syscall/handler.h create mode 100644 kernel/syscall/skeleton.cc create mode 100644 kernel/syscall/skeleton.h create mode 100644 kernel/syscall/stub.asm create mode 100644 kernel/syscall/stub.h create mode 100644 kernel/thread/dispatcher.cc create mode 100644 kernel/thread/dispatcher.h create mode 100644 kernel/thread/idlethread.cc create mode 100644 kernel/thread/idlethread.h create mode 100644 kernel/thread/scheduler.cc create mode 100644 kernel/thread/scheduler.h create mode 100644 kernel/thread/thread.cc create mode 100644 kernel/thread/thread.h create mode 100644 kernel/types.h create mode 100644 kernel/user/app1/appl.cc create mode 100644 kernel/user/app1/appl.h create mode 100644 kernel/user/app2/kappl.cc create mode 100644 kernel/user/app2/kappl.h create mode 100644 kernel/user/loader.cc create mode 100644 kernel/utils/alloc.cc create mode 100644 kernel/utils/alloc.h create mode 100644 kernel/utils/math.h create mode 100644 kernel/utils/png.cc create mode 100644 kernel/utils/png.h create mode 100644 kernel/utils/random.cc create mode 100644 kernel/utils/random.h create mode 100644 kernel/utils/size.h create mode 100644 kernel/utils/sort.h create mode 100644 kernel/utils/string.cc create mode 100644 kernel/utils/string.h create mode 100644 libsys/Makefile create mode 100644 libsys/iostream.h create mode 120000 libsys/libc.cc create mode 120000 libsys/libc.h create mode 120000 libsys/math.h create mode 120000 libsys/outputstream.cc create mode 120000 libsys/outputstream.h create mode 100644 libsys/rand.cc create mode 100644 libsys/rand.h create mode 120000 libsys/string.cc create mode 120000 libsys/string.h create mode 120000 libsys/stringbuffer.cc create mode 120000 libsys/stringbuffer.h create mode 120000 libsys/stub.asm create mode 120000 libsys/stub.h create mode 120000 libsys/types.h create mode 100644 nix-develop.sh create mode 100644 tools/build.mk create mode 100644 tools/common.mk create mode 100644 tools/cpplint.py create mode 100644 tools/image.mk create mode 100644 tools/linter.mk create mode 100644 tools/qemu.mk create mode 100644 tools/remote.mk create mode 100644 user/Makefile create mode 100644 utils/flake.lock create mode 100644 utils/flake.nix diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..c816d1b --- /dev/null +++ b/.clang-format @@ -0,0 +1,4 @@ +BasedOnStyle: Google +UseTab: Always +TabWidth: 4 +IndentWidth: 4 diff --git a/.clang-format-ignore b/.clang-format-ignore new file mode 100644 index 0000000..1f94732 --- /dev/null +++ b/.clang-format-ignore @@ -0,0 +1,2 @@ +**/assets/* +**/fonts/* diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 0000000..d3e9cf4 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,6 @@ +FormatStyle: google +HeaderFilterRegex: '.*' +WarningsAsErrors: 'readability*' +Checks: 'readability*,google-readability-casting,google-explicit-constructor,bugprone*,-bugprone-narrowing-conversions,-bugprone-reserved-identifier,-readability-else-after-return,-readability-magic-numbers,-readability-identifier-length,-readability-braces-around-statements,cppcoreguidelines-*,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-pro-*,-cppcoreguidelines-avoid-do-while,-cppcoreguidelines-owning-memory' +CheckOptions: + readability-simplify-boolean-expr.IgnoreMacros: 'true' diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..3091196 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +use flake $PWD/utils/flake.nix --no-pure-eval diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d95f4fd --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +.build* +/build* diff --git a/CPPLINT.cfg b/CPPLINT.cfg new file mode 100644 index 0000000..22e2e0f --- /dev/null +++ b/CPPLINT.cfg @@ -0,0 +1,16 @@ +# StuBS Coding Style Checker +# +# Wir orientieren uns grob an den Google C++ Style Guide ( http://google.github.io/styleguide/cppguide.html ) +# mit primär folgenden Änderungen/Anpassungen: +# +# - Tabs statt Leerzeichen. Spart Bytes ;) +# - Zeilenlänge ist 120 +# - Keine Angaben zum Copyright +# - Aufgrund des Aufgabenbuildsystems sind neue / leere Zeilen leider nicht immer vermeidbar +# +# Zum Prüfen empfiehlt sich beispielsweise das Pythonscript CPPLINT.py ( https://github.com/cpplint/cpplint ) +# welches mit dieser Konfigurationsdatei arbeiten kann. +# +set noparent +filter=-whitespace/tab,-legal/copyright,-runtime/int,-runtime/threadsafe_fn,-readability/todo,-build/include_subdir,-runtime/references,-build/include_what_you_use,-whitespace/blank_line,-build/include,-whitespace/end_of_line,-whitespace/indent +linelength=120 diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..72c95aa --- /dev/null +++ b/LICENSE @@ -0,0 +1,14 @@ +Copyright 1998-2002 Institut für Verteilte Systeme (IVS), Otto-von-Guericke-Universität Magdeburg +Copyright 2002-2019 Lehrstuhl für Informatik 4, Friedrich-Alexander-Universität Erlangen-Nürnberg +Copyright 2017- System- und Rechnerarchitektur (SRA), Leibniz Universität Hannover +Copyright 2021-2023 Operating System Group (OSG), Technische Universität Hamburg +Copyright 2024- Verlässliche Systemsoftware (VSS), Technische Universität Braunschweig + +Diese Vorlage dient als Grundlage für Lehrveranstaltungen und darf nicht ohne vorherige, schriftliche Erlaubnis der Urheberrechtsinhaber veröffentlicht oder weitergegeben werden. +Es ist erlaubt und wünschenswert, diese Vorlage als Inspiration für eigene Projekte zu verwenden, es wird allerdings erbeten, dass die Vorgabe nicht mit deiner Lösung veröffentlicht wird. +Wir, als Lehrende, möchten alle teilnehmenden Studierenden dazu ermutigen eine eigene Lösung zu erstellen; eine veröffentlichte Lösung ist ein Anreiz zum Abschreiben, den wir gerne vermeiden möchten. + + +This skeleton is provided as a foundation for educational purposes and therefore MUST NOT BE DISTRIBUTED OR PUBLISHED without prior, written consent of the copyright holders. +You are free to use this skeleton as inspiration for your projects, but, please, do not publish it along with your solution. +We, as lecturers, want to encourage every participating student to write a solution themself; a public solution is an allurement to copying we want to avoid. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..8977e34 --- /dev/null +++ b/Makefile @@ -0,0 +1,31 @@ +# Default target +.DEFAULT_GOAL = all + +echo=$(shell which echo) -e + +# Paths to kernel and userspace for StuBSmI +# (Note: also defined as relative paths in {user,kernel}/Makefile!) +INITRD = user/$(BUILDDIR)/initrd.img +KERNEL = kernel/$(BUILDDIR)/system +KERNEL64 = kernel/$(BUILDDIR)/system64 +KERNEL_LINK = kernel/$(BUILDDIR)/system +ISOFILE = kernel/$(BUILDDIR)/stubs.iso + +SUBDIRS = kernel +SUBDIRS += user + +# Default targets +include tools/common.mk + +all: + $(VERBOSE) $(foreach DIR,$(SUBDIRS),$(MAKE) -C $(DIR) && ) true + +lint:: + $(VERBOSE) $(foreach DIR,$(SUBDIRS),$(MAKE) -C $(DIR) lint && ) true + +tidy:: + $(VERBOSE) $(foreach DIR,$(SUBDIRS),$(MAKE) -C $(DIR) tidy && ) true + +# clean all apps additionally to default clean recipe from common.mk +clean:: + $(VERBOSE) $(foreach DIR,$(SUBDIRS),$(MAKE) -C $(DIR) clean && ) true diff --git a/README.md b/README.md new file mode 100644 index 0000000..f210cca --- /dev/null +++ b/README.md @@ -0,0 +1,42 @@ +# StuBSmI - Studenten Betriebssystem mit Isolation + + +## Coding Guidelines + +Similar to [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) but with following exceptions: + - No license boilerplate + - *Tabs* instead of *Spaces* + - Line length of 120 characters + - `#pragma once` instead of `#include` guards + +The code should be *self-documenting*, don't state the obvious! +However, this does not make comments superfluous: +Since good naming is sometimes not enough, more advanced parts need to be documented, +so any operating system developer should be able to easily understand your code. + + +### Naming Convention + + - **Variables**: lowercase with underscore + + char* variable_name; + + - **Constants** (and **enum** values): uppercase with underscore + + const int CONST_VALUE = 42; + + - **Type Names** (`class`/`struct`/`namespace`/`enum`): Capital letter, camel case + + class SomeClassName; + + - **Methods/Functions** (C++): start with lowercase letter, then camel case + + void someFunctionName(); + + - **extern "C" Functions**: lowercase with underscore (like variables). + + void interrupt_handler(int vector); + + - **File Names**: lowercase, main type name, underscores only if is a sub type + + folder/classname.cc diff --git a/kernel/CPPLINT.cfg b/kernel/CPPLINT.cfg new file mode 100644 index 0000000..dcb0cb6 --- /dev/null +++ b/kernel/CPPLINT.cfg @@ -0,0 +1,3 @@ +exclude_files=memory/* +exclude_files=test_imgs/* +exclude_files=config\.h diff --git a/kernel/Makefile b/kernel/Makefile new file mode 100644 index 0000000..d29f5f6 --- /dev/null +++ b/kernel/Makefile @@ -0,0 +1,36 @@ +# Kernel Makefile +# try `make help` for more information +echo=$(shell which echo) -e + +# Default target +.DEFAULT_GOAL = all + +# Kernel source files +LINKER_SCRIPT = compiler/sections.ld +CC_SOURCES = $(shell find * -name "*.cc" -a ! -name '.*' -a ! -path 'test*' -a ! -path 'fs/tool/*' -a ! -path 'assets/*' -a ! -path 'tools/*') +ASM_SOURCES = $(shell find * -name "*.asm" -a ! -name '.*') + +# Target files +KERNEL = $(BUILDDIR)/system +KERNEL64 = $(KERNEL)64 +ISOFILE = $(BUILDDIR)/stubs.iso +KERNEL_LINK = $(ROOTBUILDDIR)/system.img + +# Include global variables and standard recipes +include ../tools/common.mk + +all: $(KERNEL) + + +# Linking the system image +# We use the C++ compiler (which calls the actual linker) +$(KERNEL64): $(ASM_OBJECTS) $(CC_OBJECTS) $(LINKER_SCRIPT) $(MAKEFILE_LIST) + @echo "LD $@" + @mkdir -p $(@D) + $(VERBOSE) $(CXX) $(CXXFLAGS) -Wl,-T $(LINKER_SCRIPT) -o $@ $(LDFLAGS) $(ASM_OBJECTS) $(CC_OBJECTS) + @echo "LN $(KERNEL_LINK)" + $(VERBOSE) ln -sf $(@:$(ROOTBUILDDIR)/%=%) "$(KERNEL_LINK)" + +# The kernel must be a 32bit elf for multiboot compliance +$(KERNEL): $(KERNEL64) + $(VERBOSE) $(OBJCOPY) -I elf64-x86-64 -O elf32-i386 $< $@ diff --git a/kernel/arch/acpi.cc b/kernel/arch/acpi.cc new file mode 100644 index 0000000..e746b59 --- /dev/null +++ b/kernel/arch/acpi.cc @@ -0,0 +1,146 @@ +#include "acpi.h" + +#include "../debug/output.h" + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Warray-bounds" + +namespace ACPI { + +static RSDP *rsdp = nullptr; +static RSDT *rsdt = nullptr; +static XSDT *xsdt = nullptr; + +constexpr const char *RSDP_SIGNATURE = "RSD PTR "; + +static int checksum(const void *pos, unsigned len) { + const uint8_t *mem = reinterpret_cast(pos); + uint8_t sum = 0; + for (unsigned i = 0; i < len; i++) { + sum += mem[i]; + } + + return sum; +} + +static const RSDP *findRSDP(const void *pos, unsigned len) { + /* since the RSDP is 16-Byte aligned, we only need to check + every second 64bit memory block */ + for (unsigned block = 0; block < len / 8; block += 2) { + const uint64_t *mem = reinterpret_cast(pos) + block; + if (*mem == *reinterpret_cast(RSDP_SIGNATURE)) { + const RSDP *rsdp = reinterpret_cast(mem); + /* ACPI Specification Revision 4.0a: 5.2.5.3*/ + if ((rsdp->revision == 0 && checksum(mem, 20) == 0) || + (rsdp->length > 20 && checksum(mem, rsdp->length) == 0)) { + return rsdp; + } + } + } + return 0; +} + +bool init() { + /* ACPI Specification Revision 4.0a: + * 5.2.5.1 Finding the RSDP on IA-PC Systems + * OSPM finds the Root System Description Pointer (RSDP) structure by + * searching physical memory ranges on 16-byte boundaries for a valid + * Root System Description Pointer structure signature and checksum + * match as follows: + * * The first 1 KB of the Extended BIOS Data Area (EBDA). For EISA or + * MCA systems, the EBDA can be found in the two-byte location 40:0Eh + * on the BIOS data area. + * * The BIOS read-only memory space between 0E0000h and 0FFFFFh. + */ + const uintptr_t ebda = + static_cast(*reinterpret_cast(0x40e)); + const RSDP *rsdp = findRSDP(reinterpret_cast(ebda), 1024); + if (rsdp == nullptr) { + rsdp = findRSDP(reinterpret_cast(0xe0000), 0xfffff - 0xe0000); + } + + if (rsdp == nullptr) { + DBG_VERBOSE << "No ACPI!" << endl; + return false; + } + rsdt = reinterpret_cast(static_cast(rsdp->rsdtaddress)); + + /* If the XSDT is present we must use it; see: + * ACPI Specification Revision 4.0a: + * "An ACPI-compatible OS must use the XSDT if present." + */ + if (rsdp->revision != 0 && rsdp->length >= 36) { + xsdt = reinterpret_cast(rsdp->xsdtaddress); + } + DBG_VERBOSE << "ACPI revision " << rsdp->revision << endl; + for (unsigned i = 0; i != count(); ++i) { + SDTH *sdt = get(i); + if (sdt != nullptr) { + char *c = reinterpret_cast(&sdt->signature); + DBG_VERBOSE << i << ". " << c[0] << c[1] << c[2] << c[3] << " @ " + << reinterpret_cast(sdt) << endl; + } + } + return true; +} + +unsigned count() { + if (xsdt != nullptr) { + return (xsdt->length - 36) / 8; + } else if (rsdt != nullptr) { + return (rsdt->length - 36) / 4; + } else { + return 0; + } +} + +SDTH *get(unsigned num) { + if (xsdt != nullptr) { + SDTH *entry = reinterpret_cast(xsdt->entries[num]); + if (checksum(entry, entry->length) == 0) { + return entry; + } + } else if (rsdt != nullptr) { + SDTH *entry = reinterpret_cast( + static_cast(rsdt->entries[num])); + if (checksum(entry, entry->length) == 0) { + return entry; + } + } + return 0; +} + +SDTH *get(char a, char b, char c, char d) { + union { + char signature[4]; + uint32_t value; + }; + signature[0] = a; + signature[1] = b; + signature[2] = c; + signature[3] = d; + + if (xsdt != nullptr) { + for (unsigned i = 0; i < count(); i++) { + SDTH *entry = reinterpret_cast(xsdt->entries[i]); + if (entry->signature == value && + checksum(entry, entry->length) == 0) { + return entry; + } + } + } else if (rsdt != nullptr) { + for (unsigned i = 0; i < count(); i++) { + SDTH *entry = reinterpret_cast( + static_cast(rsdt->entries[i])); + if (entry->signature == value && + checksum(entry, entry->length) == 0) { + return entry; + } + } + } + return 0; +} + +int revision() { return rsdp != nullptr ? rsdp->revision : -1; } + +} // namespace ACPI diff --git a/kernel/arch/acpi.h b/kernel/arch/acpi.h new file mode 100644 index 0000000..89d022b --- /dev/null +++ b/kernel/arch/acpi.h @@ -0,0 +1,270 @@ +/*! \file + * \brief Structs and methods related to the \ref ACPI "Advanced Configuration + * and Power Interface (ACPI)"" + */ + +#pragma once +#include "../types.h" + +/*! \brief Abstracts the ACPI standard that provides interfaces for hardware + * detection, device configuration, and energy management. + * \ingroup io + * + * ACPI is the successor to APM (Advanced Power Management), aiming to give the + * operating system more control over the hardware. This extended control, for + * instance, enables the operating system to assign a particular amount of + * energy to every device (e.g., by disabling a device or changing to standby + * mode). For this purpose, BIOS and chipset provide a set of tables that + * describe the system and its components and provide routines the OS can call. + * These tables contain details about the system, such as the number of CPU + * cores and the LAPIC/IOAPIC, which are determined during system boot. + */ + +namespace ACPI { + +/*! \brief Root System Description Pointer (RSDP) + * + * The first step to using ACPI is finding the RSDP that is used to find the + * RSDT / XSDT, which themselves contain pointers to even more tables. + * + * On UEFI systems, the RSDP can be found in the EFI_SYSTEM_TABLE; for non-UEFI + * systems we have to search for the signature 'RSD PTR ' in the EBDA (Extended + * Bios Data Area) or in the memory area up to `FFFFFh`. + * + * \see [ACPI-Specification 5.2.5.3; Root System Description Pointer (RSDP) + * Structure](acpi.pdf#page=161) + */ + +struct RSDP { + char signature[8]; /* must exactly be equal to 'RSD PTR ' */ + uint8_t checksum; + char oemid[6]; + uint8_t revision; /* specifies the ACPI version */ + uint32_t rsdtaddress; /* physical address of the RSDT */ + uint32_t length; + uint64_t xsdtaddress; /* physical address of the XSDT */ + uint8_t extended_checksum; + uint8_t reserved[3]; +} __attribute__((packed)); + +/*! \brief System Description Table Header (SDTH) + * + * All System Description Tables (e.g., the RSDT) contain the same entries at + * the very beginning of the structure, which are abstracted in the SDTH. + * + * \see [ACPI-Specification 5.2.6; System Description Table + * Header](acpi.pdf#page=162) + */ +struct SDTH { + uint32_t signature; /* table id */ + uint32_t length; + uint8_t revision; + uint8_t checksum; + char oemid[6]; + char oem_table_id[8]; + uint32_t oem_revision; + uint32_t creator_id; + uint32_t creator_revision; + + /* \brief Helper method + * \return Pointer to the end of the table + */ + void *end() { return reinterpret_cast(this) + length; } +} __attribute__((packed)); + +/*! \brief Root System Description Table (RSDT) + * + * The RSDT can be found in the RSDP. The RSDT contains physical addresses of + * all other System Description Tables, for example the MADT. + * + * \see [ACPI-Specification 5.2.7; Root System Description Table + * (RSDT)](acpi.pdf#page=167) + */ + +struct RSDT : SDTH { + uint32_t entries[]; +} __attribute__((packed)); + +/*! \brief Extended System Description Table (XSDT) + * + * Like RSDT, but contains 64-bit instead of 32-bit addresses. + * + * \see [ACPI-Specification 5.2.8; Extended System Description Table + * (XSDT)](acpi.pdf#page=168) + */ + +struct XSDT : SDTH { + uint64_t entries[]; +} __attribute__((packed)); + +/*! \brief Helper structure + * + * Is used for accessing the substructures present in SRAT / MADT. + * + */ +struct SubHeader { + uint8_t type; + uint8_t length; + + /* Method to traverse multiple substructures */ + SubHeader *next() { + return reinterpret_cast(reinterpret_cast(this) + + length); + } +} __attribute__((packed)); + +/*! \brief Multiple APIC Description Table (MADT) + * + * Describes all interrupt controllers present within the system. Is used to + * obtain the IDs of the APICs, along with the number of available processor + * cores. + * + * \see [ACPI-Specification 5.2.12; Multiple APIC Description Table + * (MADT)](acpi.pdf#page=193) + */ +struct MADT : SDTH { + uint32_t local_apic_address; + uint32_t flags_pcat_compat : 1, flags_reserved : 31; + + /* method to access the first subheader */ + SubHeader *first() { + return reinterpret_cast(reinterpret_cast(this) + + sizeof(MADT)); + } +} __attribute__((packed)); + +enum class AddressSpace : uint8_t { + MEMORY = 0x0, + IO = 0x1, +}; + +/*! \brief ACPI address format + * + * The ACPI standard defines its own address format that is able to handle + * addresses both in memory address space, as well as IO-port address space. + */ +struct Address { + AddressSpace address_space; + uint8_t register_bit_width; + uint8_t register_bit_offset; + uint8_t reserved; + uint64_t address; +} __attribute__((packed)); + +// Multiple APIC Definition Structure +namespace MADS { +enum Type { + Type_LAPIC = 0, + Type_IOAPIC = 1, + Type_Interrupt_Source_Override = 2, + Type_LAPIC_Address_Override = 5, +}; + +/*! \brief Processor Local APIC (LAPIC) Structure + * + * Represents a physical processor along with its local interrupt controller. + * The MADT contains a LAPIC structure for every processor available in the + * system. + * + * \see [ACPI-Specification 5.2.12.2; Processor Local APIC + * Structure](acpi.pdf#page=195) + */ +struct LAPIC : SubHeader { + uint8_t acpi_processor_id; + uint8_t apic_id; + uint32_t flags_enabled : 1, flags_reserved : 31; /* must be 0 */ +} __attribute__((packed)); + +/*! \brief I/O APIC Structure + * + * Represents an I/O-APIC. + * The MADT contains an IOAPIC structure for every I/O APIC present in the + * system. + * + * \see [ACPI-Specification 5.2.12.3; I/O APIC Structure](acpi.pdf#page=196) + */ + +struct IOAPIC : SubHeader { + uint8_t ioapic_id; + uint8_t reserved; + uint32_t ioapic_address; + uint32_t global_system_interrupt_base; +} __attribute__((packed)); + +/*! \brief Interrupt Source Override Structure + * + * Is required to describe differences between the IA-PC standard interrupt + * definition and the actual hardware implementation. + * + * \see [ACPI-Specification 5.2.12.5; Interrupt Source Override + * Structure](acpi.pdf#page=197) + */ +struct Interrupt_Source_Override : SubHeader { + uint8_t bus; + uint8_t source; + uint32_t global_system_interrupt; + uint16_t flags_polarity : 2, flags_trigger_mode : 2, + flags_reserved : 12; /* must be 0 */ +} __attribute__((packed)); + +/*! \brief Local APIC Address Override Structure + * + * Support for 64-bit systems is achieved by replacing the 32-bit physical LAPIC + * address stored in the MADT with the corresponding 64-bit address. + * + * \see [ACPI-Specification 5.2.12.8; Local APIC Address Override + * Structure](acpi.pdf#page=199) + */ + +struct LAPIC_Address_Override : SubHeader { + uint16_t reserved; + union { + uint64_t lapic_address; + struct { + uint32_t lapic_address_low; + uint32_t lapic_address_high; + } __attribute__((packed)); + }; +} __attribute__((packed)); + +} // namespace MADS + +/*! \brief Initialize the ACPI description table + * + * Searches physical memory ranges o 16-byte boundaries for a valid Root System + * Description Pointer (RSDP) structure signature and checksum. If present, the + * superseding Extended System Description Table (XSDT) is used. + * + * \see [ACPI-Specification 5.2.5 Root System Description Pointer + * (RSDP)](acpi.pdf#page=160) + * \see [ACPI-Specification 5.2.8 Extended System Description Table + * (XSDT)](acpi.pdf#page=168) + */ +bool init(); + +/*! \brief Number of entries in the description table + */ +unsigned count(); + +/*! \brief Get entry of description table by index + * + * \param num index in description table + * \return Pointer to corresponding entry or `nullptr` if not available + */ +SDTH *get(unsigned num); + +/*! \brief Get entry of description table by four character identifier + * + * \param a first character of identifier + * \param b second character of identifier + * \param c third character of identifier + * \param d forth and last character of identifier + * \return Pointer to corresponding entry or `nullptr` if not available + */ +SDTH *get(char a, char b, char c, char d); + +/*! \brief Retrieve the revision from the Root System Description Pointer (RSDP) + */ +int revision(); + +} // namespace ACPI diff --git a/kernel/arch/apic.cc b/kernel/arch/apic.cc new file mode 100644 index 0000000..54f146e --- /dev/null +++ b/kernel/arch/apic.cc @@ -0,0 +1,161 @@ +#include "apic.h" + +#include "../debug/assert.h" +#include "../debug/output.h" +#include "acpi.h" +#include "core.h" +#include "ioport.h" +#include "lapic_registers.h" + +namespace APIC { + +static struct { + uint32_t id; + uintptr_t address; + uint32_t interrupt_base; +} ioapic; + +static uint8_t slot_map[16]; + +static uint8_t lapic_id[Core::MAX]; +static unsigned lapics = 0; + +bool init() { + // get Multiple APIC Definition Table (MADT) from ACPI + ACPI::MADT* madt = static_cast(ACPI::get('A', 'P', 'I', 'C')); + if (madt == 0) { + DBG_VERBOSE << "ERROR: no MADT found in ACPI" << endl; + return false; + } + + // read the local APIC address + LAPIC::base_address = static_cast(madt->local_apic_address); + DBG_VERBOSE << "LAPIC Address " + << reinterpret_cast( + static_cast(madt->local_apic_address)) + << endl; + + // PC/AT compatibility mode + if (madt->flags_pcat_compat != 0) { + // The APIC operating mode is set to compatible PIC mode - we have to + // change it. + DBG_VERBOSE << "PIC comp mode, disabling PICs." << endl; + + // Select Interrupt Mode Control Register (IMCR) + // (this register will only exist if hardware supports the PIC mode) + IOPort reg(0x22); + reg.outb(0x70); + // disable PIC mode, use APIC + IOPort imcr(0x23); + imcr.outb(0x01); + } + + // Set default mapping of external interrupt slots (might be overwritten + // below) + for (unsigned i = 0; i < sizeof(slot_map) / sizeof(slot_map[0]); i++) { + slot_map[i] = i; + } + + // Initialize invalid lapic_ids + for (unsigned i = 0; i < Core::MAX; i++) { + lapic_id[i] = INVALID_ID; + } + + // reset numbers, store apic data into arrays + for (ACPI::SubHeader* mads = madt->first(); mads < madt->end(); + mads = mads->next()) { + switch (mads->type) { + case ACPI::MADS::Type_LAPIC: { + ACPI::MADS::LAPIC* mads_lapic = + static_cast(mads); + if (mads_lapic->flags_enabled == 0) { + DBG_VERBOSE << "Detected disabled LAPIC with ID " + << static_cast(mads_lapic->apic_id) + << endl; + } else if (lapics >= Core::MAX) { + DBG_VERBOSE << "Got more LAPICs than Core::MAX" << endl; + } else if (mads_lapic->apic_id == INVALID_ID) { + DBG_VERBOSE << "Got invalid APIC ID" << endl; + } else { + DBG_VERBOSE << "Detected LAPIC with ID " + << static_cast(mads_lapic->apic_id) + << endl; + lapic_id[lapics++] = mads_lapic->apic_id; + } + break; + } + case ACPI::MADS::Type_IOAPIC: { + ACPI::MADS::IOAPIC* mads_ioapic = + static_cast(mads); + DBG_VERBOSE << "Detected IO APIC with ID " + << static_cast(mads_ioapic->ioapic_id) + << " / Base " + << reinterpret_cast(static_cast( + mads_ioapic->global_system_interrupt_base)) + << endl; + if (mads_ioapic->global_system_interrupt_base > 23) { + DBG_VERBOSE << "Ignoring IOAPIC since we currently only " + "support one." + << endl; + } else { + ioapic.id = mads_ioapic->ioapic_id; + ioapic.address = + static_cast(mads_ioapic->ioapic_address); + ioapic.interrupt_base = + mads_ioapic->global_system_interrupt_base; + } + break; + } + case ACPI::MADS::Type_Interrupt_Source_Override: { + ACPI::MADS::Interrupt_Source_Override* mads_iso = + static_cast(mads); + if (mads_iso->bus == 0) { + DBG_VERBOSE << "Overriding Interrupt Source " + << static_cast(mads_iso->source) + << " with " << mads_iso->global_system_interrupt + << endl; + if (mads_iso->source < + sizeof(slot_map) / sizeof(slot_map[0])) { + slot_map[mads_iso->source] = + mads_iso->global_system_interrupt; + } + } else { + DBG_VERBOSE << "Override for bus " << mads_iso->bus + << " != ISA. Does not conform to ACPI." << endl; + } + break; + } + case ACPI::MADS::Type_LAPIC_Address_Override: { + ACPI::MADS::LAPIC_Address_Override* mads_lao = + static_cast(mads); + LAPIC::base_address = + static_cast(mads_lao->lapic_address_low); + DBG_VERBOSE << "Overriding LAPIC address with " + << reinterpret_cast(static_cast( + mads_lao->lapic_address)) + << endl; + break; + } + } + } + return true; +} + +uint8_t getIOAPICSlot(APIC::Device device) { + return slot_map[static_cast(device)]; +} + +uintptr_t getIOAPICAddress() { return ioapic.address; } + +uint8_t getIOAPICID() { return ioapic.id; } + +uint8_t getLogicalAPICID(uint8_t core) { + return core < Core::MAX ? (1 << core) : 0; +} + +uint8_t getLAPICID(uint8_t core) { + assert(core < Core::MAX); + return lapic_id[core]; +} + +} // namespace APIC diff --git a/kernel/arch/apic.h b/kernel/arch/apic.h new file mode 100644 index 0000000..bb38eaf --- /dev/null +++ b/kernel/arch/apic.h @@ -0,0 +1,82 @@ +/*! \file + * \brief Gather system information from the \ref ACPI about the \ref APIC + * "Advanced Programmable Interrupt Controller (APIC)" + */ + +#pragma once +#include "../types.h" + +/*! \brief Information about the (extended) Advanced Programmable Interrupt + * Controller + */ +namespace APIC { +/*! \brief Historic order of interrupt lines (PIC) + */ +enum class Device : uint8_t { + TIMER = 0, ///< Programmable Interrupt Timer (\ref PIT) + KEYBOARD = 1, ///< Keyboard + COM1 = 4, ///< First serial interface + COM2 = 3, ///< Second serial interface + COM3 = 4, ///< Third serial interface (shared with COM1) + COM4 = 3, ///< Forth serial interface (shared with COM2) + FLOPPY = 6, ///< Floppy device + LPT1 = 7, ///< Printer + REALTIMECLOCK = 8, ///< Real time clock + PS2MOUSE = 12, ///< Mouse + IDE1 = 14, ///< First hard disk + IDE2 = 15 ///< Second hard disk +}; + +/*! \brief Invalid APIC ID + * + * The highest address is reserved according to xAPIC specification + */ +const uint8_t INVALID_ID = 0xff; + +/*! \brief Executes system detection + * + * Searches and evaluates the APIC entries in the \ref ACPI table. + * This function recognizes a possibly existing multicore system. + * After successful detection, the number of available CPUs (which is equal + * to the number of \ref LAPIC "local APICs") ) can be queried + * using the method \ref Core::count(). + * + * \note Called by \ref kernel_init() on BSP + * + * \return `true` if detection of the APIC entries was successful + */ +bool init(); + +/*! \brief Queries the I/O-APIC address determined during system boot + * + * \return Base address of the (first & only supported) I/O APIC + */ +uintptr_t getIOAPICAddress(); + +/*! \brief Queries of ID of the I/O-APIC determined during system boot + * + * \return Identification of the (first & only supported) I/O APIC + */ +uint8_t getIOAPICID(); + +/*! \brief Returns the pin number the \p device is connected to. + */ +uint8_t getIOAPICSlot(APIC::Device device); + +/*! \brief Returns the logical ID of the Local APIC passed for \a core. + * + * The LAPIC's logical ID is set (by StuBS) during boot such that exactly one + * bit is set per CPU core. For core 0, bit 0 is set in its ID, while core 1 has + * bit 1 set, etc. + * + * \param core The queried CPU core + */ +uint8_t getLogicalAPICID(uint8_t core); + +/*! \brief Get the Local APIC ID of a CPU + * \param core Query CPU core number + * \return LAPIC ID of CPU or INVALID_ID if invalid CPU ID + */ +uint8_t getLAPICID(uint8_t core); + +} // namespace APIC diff --git a/kernel/arch/cache.h b/kernel/arch/cache.h new file mode 100644 index 0000000..c4e7c9e --- /dev/null +++ b/kernel/arch/cache.h @@ -0,0 +1,22 @@ +/*! \file + * \brief Helper for cache alignment + */ + +#pragma once + +#include "../debug/assert.h" + +// Helper for aligning to cache line (to prevent false sharing) +#ifndef CACHE_LINE_SIZE +#define CACHE_LINE_SIZE 64 +#endif +#define cache_aligned alignas(CACHE_LINE_SIZE) + +/*! + * \def assert_cache_aligned(TYPE) + * \brief Compile time check of cache alignment + * \param TYPE data type to check + */ +#define assert_cache_aligned(TYPE) \ + static_assert(sizeof(TYPE) % CACHE_LINE_SIZE == 0, \ + STRINGIFY(TYPE) "Not aligned on cache boundary") diff --git a/kernel/arch/cga.cc b/kernel/arch/cga.cc new file mode 100644 index 0000000..033c013 --- /dev/null +++ b/kernel/arch/cga.cc @@ -0,0 +1,78 @@ +#include "cga.h" + +#include "../utils/math.h" +#include "ioport.h" + +namespace CGA { +// I/O Ports required for hardware cursor +constexpr IOPort index_port(0x3d4); ///< Graphic card register selection +constexpr IOPort data_port(0x3d5); ///< Read/Write selected register + +/*! \brief Helper structure for the hardware cursor + */ +union Cursor { + uint16_t value; + struct { + uint16_t low : 8; + uint16_t high : 6; + uint16_t : 2; + } __attribute__((packed)); +} __attribute__((packed)); + +/*! \brief Register (for index_port) + */ +enum RegisterIndex { + CURSOR_START = + 10, ///< Control the cursor (blink timing and start scanline) + CURSOR_END = 11, ///< Control the cursors end scanline + START_ADDRESS_HIGH = 12, ///< Base offset address for output (high) + START_ADDRESS_LOW = 13, ///< Base offset address for output (low) + CURSOR_HIGH = 14, ///< Cursor offset address (high) + CURSOR_LOW = 15, ///< Cursor offset address (low) +}; + +void setCursor(unsigned abs_x, unsigned abs_y) { + // Using the hardware cursor is quite important: + // The access to the IO Ports is rather slow and -- if interrupted by + // another output -- it will result in a strange word jumble. + // Hence this helps in a quite visible manner to understand the + // necessity of correct synchronization (and its performance impact). + if (abs_x < COLUMNS && abs_y < ROWS) { + Cursor pos = {static_cast((abs_y * COLUMNS) + abs_x)}; + + // Select index 14 / CURSOR_HIGH register + index_port.outb(CURSOR_HIGH); + // Write high part of value to selected register (cursor high) + data_port.outb(pos.high); + // Select index 15 / CURSOR_LOW register + index_port.outb(CURSOR_LOW); + // Write low part of value to selected register (cursor low) + data_port.outb(pos.low); + } +} + +void getCursor(unsigned& abs_x, unsigned& abs_y) { + Cursor pos = {.value = 0}; + + // Select index 14 / CURSOR_HIGH register + index_port.outb(CURSOR_HIGH); + // Read high part part of value from selected register (cursor high) + pos.high = data_port.inb(); + // Select index 15 / CURSOR_LOW register + index_port.outb(CURSOR_LOW); + // Read low part of value from selected register (cursor low) + pos.low = data_port.inb(); + + // Calculate absolute position + abs_x = pos.value % COLUMNS; + abs_y = Math::min(pos.value / COLUMNS, ROWS - 1); +} + +void show(unsigned abs_x, unsigned abs_y, char character, Attribute attrib) { + // Output only on current page + if (abs_x < COLUMNS && abs_y < ROWS) { + Cell cell(character, attrib); + TEXT_BUFFER_BASE[(abs_y * COLUMNS) + abs_x] = cell; + } +} +}; // namespace CGA diff --git a/kernel/arch/cga.h b/kernel/arch/cga.h new file mode 100644 index 0000000..7f004cc --- /dev/null +++ b/kernel/arch/cga.h @@ -0,0 +1,135 @@ +/*! \file + * \brief \ref CGA provides a basic interface to display a character in + * VGA-compatible text mode + */ + +#pragma once +#include "../types.h" + +/*! \brief Basic operations in the VGA-compatible text mode + * \ingroup io + * + * This namespace provides an interface to access the screen in text mode + * (also known as CGA mode), with access directly on the hardware + * level, i.e. the video memory and the I/O ports of the graphics + * card. + */ +namespace CGA { +constexpr unsigned ROWS = 25; ///< Visible rows in text mode +constexpr unsigned COLUMNS = 80; ///< Visible columns in text mode + +/*! \brief CGA color palette + * + * Colors for the attribute byte. + * All 16 colors can be used for the foreground while the background colors + * are limited to the first eight (from`BLACK` to `LIGHT_GREY`) + */ +enum class Color { + BLACK, ///< Black (fore- and background) + BLUE, ///< Blue (fore- and background) + GREEN, ///< Green (fore- and background) + CYAN, ///< Cyan (fore- and background) + RED, ///< Red (fore- and background) + MAGENTA, ///< Magenta (fore- and background) + BROWN, ///< Brown (fore- and background) + LIGHT_GREY, ///< Light grey (fore- and background) + DARK_GREY, ///< Dark grey (foreground only) + LIGHT_BLUE, ///< Light blue (foreground only) + LIGHT_GREEN, ///< Light green (foreground only) + LIGHT_CYAN, ///< Light cyan (foreground only) + LIGHT_RED, ///< Light red (foreground only) + LIGHT_MAGENTA, ///< Light magenta (foreground only) + YELLOW, ///< Yellow (foreground only) + WHITE ///< White (foreground only) +}; + +/*! \brief Structure of a character attribute + * consists of 4 bit fore- and 3 bit background color, and a single blink bit. + * + * [Bit fields](https://en.cppreference.com/w/cpp/language/bit_field) can + * notably simplify the access and code readability. + * + * \note [Type punning](https://en.wikipedia.org/wiki/Type_punning#Use_of_union) + * is indeed undefined behavior in C++. However, *gcc* explicitly allows + * this construct as a [language extension](https://gcc.gnu.org/bugs/#nonbugs). + * Some compilers ([other than + * gcc](https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#Type%2Dpunning) + * might allow this feature only by disabling strict aliasing + * (`-fno-strict-aliasing`). In \StuBS we use this feature extensively due to + * the improved code readability. + * + */ +union Attribute { + struct { + uint8_t foreground : 4; ///< `.... XXXX` Foreground color + uint8_t background : 3; ///< `.XXX ....` Background color + uint8_t blink : 1; ///< `X... ....` Blink + } __attribute__((packed)); + uint8_t value; ///< combined value + + /*! \brief Attribute constructor (with default values) + * + * + * \param foreground Foreground color (Default: \ref LIGHT_GREY) + * \param background Background color (Default: \ref BLACK) + * \param blink Blink if `true` (default: no blinking) + */ + explicit Attribute(Color foreground = Color::LIGHT_GREY, + Color background = Color::BLACK, bool blink = false) + : foreground(uint8_t(foreground)), + background(uint8_t(background) & 0x07), + blink(blink ? 1 : 0) { // NOLINT + } +} __attribute__((packed)); // prevent padding by the compiler + +/*! \brief Set the keyboard hardware cursor to absolute screen position + * + * + * \param abs_x absolute column of the keyboard hardware cursor + * \param abs_y absolute row of the keyboard hardware cursor + */ +void setCursor(unsigned abs_x, unsigned abs_y); + +/*! \brief Retrieve the keyboard hardware cursor position on screen + * + * + * \param abs_x absolute column of the keyboard hardware cursor + * \param abs_y absolute row of the keyboard hardware cursor + */ +void getCursor(unsigned& abs_x, unsigned& abs_y); + +/*! \brief Basic output of a character at a specific position on the screen. + * + * This method outputs the given character at the absolute screen position + * (`x`, `y`) with the specified color attribute. + * + * The position (`0`,`0`) indicates the upper left corner of the screen. + * The attribute defines characteristics such as background color, + * foreground color and blinking. + * + * \param abs_x Column (`abs_x` < \ref COLUMNS) in which the character should be + * displayed + * \param abs_y Row (`abs_y` < \ref ROWS) in which the character should be + * displayed + * \param character Character to be displayed + * \param attrib Attribute with color settings + * + */ +void show(unsigned abs_x, unsigned abs_y, char character, + Attribute attrib = Attribute()); + +/*! \brief Structure for a cell in text mode + * + * Consisting of two bytes, character and attribute + */ +struct Cell { + char character; + Attribute attribute; + Cell(char character, Attribute attribute) + : character(character), attribute(attribute) {} +} __attribute__((packed)); + +/*! \brief Base address for linear text buffer in video memory + */ +Cell* const TEXT_BUFFER_BASE = reinterpret_cast(0xb8000); +}; // namespace CGA diff --git a/kernel/arch/cmos.cc b/kernel/arch/cmos.cc new file mode 100644 index 0000000..779938e --- /dev/null +++ b/kernel/arch/cmos.cc @@ -0,0 +1,61 @@ +#include "cmos.h" + +#include "core_interrupt.h" +#include "ioport.h" + +namespace CMOS { +static constexpr IOPort address(0x70); +static constexpr IOPort data(0x71); + +namespace NMI { +static constexpr uint8_t mask = 0x80; +// Cache NMI to speed things up +static bool disabled = false; + +void enable() { + bool status = Core::Interrupt::disable(); + uint8_t value = address.inb(); + value &= ~mask; + address.outb(value); + Core::Interrupt::restore(status); + disabled = false; +} + +void disable() { + bool status = Core::Interrupt::disable(); + uint8_t value = address.inb(); + value |= mask; + address.outb(value); + Core::Interrupt::restore(status); + disabled = true; +} + +bool isEnabled() { + disabled = (address.inb() & mask) != 0; + return !disabled; +} +} // namespace NMI + +static void setAddress(enum Register reg) { + uint8_t value = static_cast(reg); + // The highest bit controls the Non Maskable Interrupt + // so we don't want to accidentally change it. + if (NMI::disabled) { + value |= NMI::mask; + } else { + value &= ~NMI::mask; + } + address.outb(value); +} + +uint8_t read(enum Register reg) { + setAddress(reg); + return data.inb(); +} + +void write(enum Register reg, uint8_t value) { + setAddress(reg); + data.outb(value); +} + +} // namespace CMOS diff --git a/kernel/arch/cmos.h b/kernel/arch/cmos.h new file mode 100644 index 0000000..6633523 --- /dev/null +++ b/kernel/arch/cmos.h @@ -0,0 +1,46 @@ +/*! \file + * \brief Controlling the \ref CMOS "complementary metal oxide semiconductor + * (CMOS)" + */ + +#pragma once +#include "../types.h" + +/*! + * \defgroup CMOS CMOS + * \brief complementary metal oxide semiconductor (CMOS) + */ + +/*! \brief CMOS + * \ingroup CMOS + */ +namespace CMOS { + +enum class Register { + SECOND = 0x0, ///< RTC + ALARM_SECOND = 0x1, ///< RTC + MINUTE = 0x2, ///< RTC + ALARM_MINUTE = 0x3, ///< RTC + HOUR = 0x4, ///< RTC + ALARM_HOUR = 0x5, ///< RTC + WEEKDAY = 0x6, ///< RTC + DAYOFMONTH = 0x7, ///< RTC + MONTH = 0x8, ///< RTC + YEAR = 0x9, ///< RTC + STATUS_A = 0xa, ///< RTC + STATUS_B = 0xb, ///< RTC + STATUS_C = 0xc, ///< RTC + STATUS_D = 0xd, ///< RTC + STATUS_DIAGNOSE = 0xe, + STATUS_SHUTDOWN = 0xf +}; + +uint8_t read(enum Register reg); +void write(enum Register reg, uint8_t value); + +namespace NMI { +void enable(); +void disable(); +bool isEnabled(); +} // namespace NMI +} // namespace CMOS diff --git a/kernel/arch/context.asm b/kernel/arch/context.asm new file mode 100644 index 0000000..fa047bc --- /dev/null +++ b/kernel/arch/context.asm @@ -0,0 +1,53 @@ +[SECTION .text] +[GLOBAL context_switch] +[GLOBAL context_launch] +[GLOBAL fake_systemv_abi] + +; context_switch saves the registers in the current context structure +; and populates the registers from the the next context. +align 16 +context_switch: + ; RDI: Pointer to next context structure + ; RSI: Pointer to current context structure + + ; Save non-scratch register of current context + mov [rsi + 0], rbx + mov [rsi + 8], rbp + mov [rsi + 16], r12 + mov [rsi + 24], r13 + mov [rsi + 32], r14 + mov [rsi + 40], r15 + ; Save stack pointer of current context + mov [rsi + 48], rsp + +; context_launch populates the register set from the next context structure. +; It does not save the current registers. +align 16 ; When only one parameter is used for `align`, it will use NOP +context_launch: + ; RDI: Pointer to next context structure + + ; Restore registers of next context + mov rbx, [rdi + 0] + mov rbp, [rdi + 8] + mov r12, [rdi + 16] + mov r13, [rdi + 24] + mov r14, [rdi + 32] + mov r15, [rdi + 40] + ; Load stack pointer of next context + mov rsp, [rdi + 48] + + ; Context switched, return + ret + +; fake_systemv_abi is used to populate the volatile argument registers used by the systemv abi (rdi, rsi, ...) +; with values from the non-volatile registers saved within the thread context (r15, r14, ...) +align 16 +fake_systemv_abi: + ; Copy first parameter (placed in R15 by context_switch) to RDI + mov rdi, r15 + ; Copy second parameter from R14 to RSI + mov rsi, r14 + ; Copy third parameter from R13 to RDX + mov rdx, r13 + ; Return to the actual target function (kickoff) + ret diff --git a/kernel/arch/context.cc b/kernel/arch/context.cc new file mode 100644 index 0000000..4931d17 --- /dev/null +++ b/kernel/arch/context.cc @@ -0,0 +1,39 @@ +#include "context.h" + +#include "../debug/assert.h" +#include "../debug/kernelpanic.h" + +/*! \brief Panic function + * + * If the kickoff function (assigned in \ref prepareContext) *returns*, this + * parameterless function will be called -- and stop the execution. + */ +static void panic() { + // we should not come back here + kernelpanic("Application should not return from context_kickoff"); +} + +void prepareContext(void* tos, Context& context, + void (*kickoff)(uintptr_t, uintptr_t, uintptr_t), + uintptr_t param1, uintptr_t param2, uintptr_t param3) { + assert(tos != nullptr && "Top Of Stack must not be nullptr"); + assert((uintptr_t)tos % 16 == 0 && "Top Of Stack be 16 byte aligned"); + assert(kickoff != nullptr && "Kickoff function missing"); + + // XXX Double check alignment. This seems to work, but the stack pointer for + // `panic` should not be aligned to 16-bit? + void** sp = reinterpret_cast(tos); + *(--sp) = reinterpret_cast(panic); // return address + *(--sp) = reinterpret_cast(kickoff); // start the thread in C land + *(--sp) = reinterpret_cast(fake_systemv_abi); // pass via registers + + context = { + .rbx = 0, + .rbp = 0, + .r12 = 0, + .r13 = param3, + .r14 = param2, // Second parameter to kickoff + .r15 = param1, // First parameter to kickoff + .rsp = reinterpret_cast(sp), + }; +} diff --git a/kernel/arch/context.h b/kernel/arch/context.h new file mode 100644 index 0000000..ff8dc4c --- /dev/null +++ b/kernel/arch/context.h @@ -0,0 +1,116 @@ +/*! \file + * \brief Functionality required for \ref context_switch "context switching" + */ + +/*! \defgroup context Context Switch + * \brief Low-Level functionality required for context switching + */ + +#pragma once +#include "../types.h" + +/*! \brief Structure for saving the CPU context when switching coroutines. + * \ingroup context + */ +struct Context { + uintptr_t rbx; ///< RBX of the thread + uintptr_t rbp; ///< RBP of the thread + uintptr_t r12; ///< R12 of the thread + uintptr_t r13; ///< R13 of the thread + uintptr_t r14; ///< R14 of the thread + uintptr_t r15; ///< R15 of the thread + void* rsp; ///< Current stack pointer of the thread +} __attribute__((packed)); + +/*! \brief Prepares a context for its first activation. +* +* \ingroup context +* +* On first activation (during *some* context switch), the execution of a +* thread should start at its entry point (typically an implementation of \ref +* Thread::kickoff). +* +* For this, we have to prepare the thread context such that \ref +* context_switch and \ref context_launch can work with it. +* +* Just pushing the entry point onto the stack as a return address is not +* sufficient, however. +* \ref Thread::kickoff requires a pointer to the current thread as a +* parameter, which we also have to transfer. According to the 64 bit SystemV +* calling convention, parameters are passed via the volatile registers `rdi, +* rsi, rcx, rdx, r8, r9`. But theses are never set during the initial context +* switch (why?). Therefore we pass the parameter using the non-volatile +* register `r15` and use a trampoline function as the actual entry point. See +* \ref fake_systemv_abi for details. +* +* `prepareContext()` can be implemented in the high-level programming language +* C++ (in file `context.cc`). +* +* \param tos Pointer to the top of stack (= address of first byte beyond +* the memory reserved for the stack) +* \param context Reference to the Context structure to be filled +* \param kickoff Pointer to the \ref Thread::kickoff function +* \param param1 first parameter for \ref Thread::kickoff function +* \param param2 second parameter for \ref Thread::kickoff function +* \param param3 third parameter for \ref Thread::kickoff function + +*/ +void prepareContext(void* tos, Context& context, + void (*kickoff)(uintptr_t, uintptr_t, uintptr_t), + uintptr_t param1, uintptr_t param2, uintptr_t param3); + +/*! \brief Executes the context switch. + * + * \ingroup context + * + * For a clean context switch, the current register values must be stored in + * the given context struct. Subsequently, these values must be restored + * accordingly from the `next` context struct. + * + * This function must be implemented in assembler in the file `context.asm` + * (why?). It must be declared as `extern "C"`, so assembler functions are not + * C++ name mangled. + * + * \param next Pointer to the structure that the next context will be read + * from + * \param current Pointer to the structure that the current context will be + * stored in + * + */ +extern "C" void context_switch(Context* next, Context* current); + +/*! \brief Launch context switching. + * + * To start context switching, the current context (from the boot-routines) is + * thrown away and the prepared register values within the given `next` context + * replace it. + * + * This function must be implemented in assembler in the file `context.asm` + * (why?). It must be declared as `extern "C"`, so assembler functions are not + * C++ name mangled. + * + * \ingroup context + * + * \param next Pointer to the structure that the next context will be read + * from + * + */ +extern "C" void context_launch(Context* next); + +/*! \brief Fakes a SystemV abi call. + * + * When a thread is first started, only non-volatile registers are "restored" + * from our prepared context (which is where we stored our \ref Thread::kickoff + * parameters). However, the 64 bit calling convention (SystemV) dictates that + * parameters are passed via the volatile registers `rdi, rsi, rcx, rdx, r8, + * r9`. In order to call a C++ function, we have to transfer our parameters from + * the non-volatile registers (e.g. `r15, ...`) to the correct volatile ones + * (`rdi, ...`). + * + * This function must be implemented in assembler in the file `context.asm` + * (why?). It must be declared as `extern "C"`, so assembler functions are not + * C++ name mangled. + * \ingroup context + * + */ +extern "C" void fake_systemv_abi(); diff --git a/kernel/arch/core.cc b/kernel/arch/core.cc new file mode 100644 index 0000000..03b9d4e --- /dev/null +++ b/kernel/arch/core.cc @@ -0,0 +1,73 @@ +#include "core.h" + +#include "apic.h" +#include "lapic.h" + +/*! \brief Initial size of CPU core stacks + * + * Used during startup in `boot/startup.asm` + */ +extern "C" const unsigned long CPU_CORE_STACK_SIZE = 4096; + +/*! \brief Reserved memory for CPU core stacks + */ +alignas( + 16) static unsigned char cpu_core_stack[Core::MAX * CPU_CORE_STACK_SIZE]; + +/*! \brief Pointer to stack memory + * + * Incremented during startup of each core (bootstrap and application + * processors) in `boot/startup.asm` + */ +unsigned char* cpu_core_stack_pointer = cpu_core_stack; + +namespace Core { + +static unsigned cores = 0; ///< Number of available CPU cores +static volatile unsigned + core_id[255]; ///< Lookup table for CPU core IDs with LAPIC ID as index + +static unsigned online_cores = 0; ///< Number of currently online CPU cores +static bool online_core[Core::MAX]; ///< Lookup table for online CPU cores with + ///< CPU core ID as index + +void init() { + // Increment number of online CPU cores + if (__atomic_fetch_add(&online_cores, 1, __ATOMIC_RELAXED) == 0) { + // Fill Lookup table + for (unsigned i = 0; i < Core::MAX; i++) { + uint8_t lapic_id = APIC::getLAPICID(i); + if (lapic_id < APIC::INVALID_ID) { // ignore invalid LAPICs + core_id[lapic_id] = i; + cores++; + } + } + } + + // Get CPU ID + uint8_t cpu = getID(); + + // initialize local APIC with logical APIC ID + LAPIC::init(APIC::getLogicalAPICID(cpu)); + + // set current CPU online + online_core[cpu] = true; +} + +void exit() { + // CPU core offline + online_core[getID()] = false; + __atomic_fetch_sub(&online_cores, 1, __ATOMIC_RELAXED); +} + +unsigned getID() { return core_id[LAPIC::getID()]; } + +unsigned count() { return cores; } + +unsigned countOnline() { return online_cores; } + +bool isOnline(uint8_t core_id) { + return core_id > Core::MAX ? false : online_core[core_id]; +} + +} // namespace Core diff --git a/kernel/arch/core.h b/kernel/arch/core.h new file mode 100644 index 0000000..f2b0749 --- /dev/null +++ b/kernel/arch/core.h @@ -0,0 +1,118 @@ +/*! \file + * \brief Access to internals of a CPU \ref Core + */ + +/*! \defgroup sync CPU Synchronization + * + * The synchronization module houses functions useful for orchestrating multiple + * processors and their activities. Synchronisation, in this case, means + * handling the resource contention between multiple participants, running on + * either the same or different cores. + */ + +#pragma once +#include "../types.h" +#include "core_cr.h" +#include "core_interrupt.h" +#include "core_msr.h" + +/*! \brief Implements an abstraction for CPU internals. + * + * These internals include functions to \ref Core::Interrupt "allow or deny + * interrupts", access \ref Core::CR "control registers" TEMPLATE(10-){ as well + * as \ref Core::MSR "model specific registers"}. + */ +namespace Core { + +/*! \brief Maximum number of supported CPUs + */ +constexpr unsigned MAX = 1; + +/*! \brief Get the ID of the current CPU core + * using \ref LAPIC::getID() with an internal lookup table. + * + * \return ID of current Core (a number between 0 and \ref Core::MAX) + */ +unsigned getID(); + +/*! \brief Initialize this CPU core + * + * Mark this core as *online* and setup the cores \ref LAPIC by assigning it a + * unique \ref APIC::getLogicalAPICID() "logical APIC ID" + * + * \note Should only be called from \ref kernel_init() during startup. + */ +void init(); + +/*! \brief Deinitialize this CPU core + * + * Mark this Core as *offline* + * + * \note Should only be called from \ref kernel_init() after returning from + * `main()` or `main_ap()`. + */ +void exit(); + +/*! \brief Get number of available CPU cores + * + * \return total number of cores + */ +unsigned count(); + +/*! \brief Get number of successfully started (and currently active) CPU cores + * + * \return total number of online cores + */ +unsigned countOnline(); + +/*! \brief Check if CPU core is currently active + * \param core_id ID of the CPU core + * \return `true` if successfully started and is currently active + */ +bool isOnline(uint8_t core_id); + +/*! \brief Gives the core a hint that it is executing a spinloop and should + * sleep "shortly" + * + * Improves the over-all performance when executing a spinloop by waiting a + * short moment reduce the load on the memory. + * + * \see [ISDMv2, Chapter 4. PAUSE - Spin Loop + * Hint](intel_manual_vol2.pdf#page=887) + */ +inline void pause() { asm volatile("pause\n\t" : : : "memory"); } + +/*! \brief Halt the CPU core until the next interrupt. + * + * Halts the current CPU core such that it will wake up on the next interrupt. + * Internally, this function first enables the interrupts via `sti` and then + * halts the core using `hlt`. Halted cores can only be woken by interrupts. The + * effect of `sti` is delayed by one instruction, making the sequence `sti hlt` + * atomic (if interrupts were disabled previously). + * + * \see [ISDMv2, Chapter 4. STI - Set Interrupt + * Flag](intel_manual_vol2.pdf#page=1297) + * \see [ISDMv2, Chapter 3. HLT - Halt](intel_manual_vol2.pdf#page=539) + */ +inline void idle() { asm volatile("sti\n\t hlt\n\t" : : : "memory"); } + +/*! \brief Permanently halts the core. + * + * Permanently halts the current CPU core. Internally, this function first + * disables the interrupts via `cli` and then halts the CPU core using `hlt`. As + * halted CPU cores can only be woken by interrupts, it is guaranteed that this + * core will be halted until the next reboot. The execution of die never + * returns. On multicore systems, only the executing CPU core will be halted + * permanently, other cores will continue execution. + * + * \see [ISDMv2, Chapter 3. CLI - Clear Interrupt + * Flag](intel_manual_vol2.pdf#page=245) + * \see [ISDMv2, Chapter 3. HLT - Halt](intel_manual_vol2.pdf#page=539) + */ +[[noreturn]] inline void die() { + while (true) { + asm volatile("cli\n\t hlt\n\t" : : : "memory"); + } +} + +} // namespace Core diff --git a/kernel/arch/core_cr.h b/kernel/arch/core_cr.h new file mode 100644 index 0000000..abf5043 --- /dev/null +++ b/kernel/arch/core_cr.h @@ -0,0 +1,83 @@ +/*! \file + * \brief Access to \ref Core::CR "Control Register" of a \ref Core "CPU core" + */ + +#pragma once +#include "../types.h" + +namespace Core { +/*! \brief Control Register 0 + * + * \see [ISDMv3, 2.5 Control Registers](intel_manual_vol3.pdf#page=74) + */ +enum class CR0 : uint32_t { + PE = 1U << 0, ///< Protected Mode enabled + MP = 1U << 1, ///< Monitor co-processor + EM = 1U << 2, ///< Emulation (no x87 floating-point unit present) + TS = 1U << 3, ///< Task switched + ET = 1U << 4, ///< Extension type + NE = 1U << 15, ///< Numeric error + WP = 1U << 16, ///< Write protect + AM = 1U << 18, ///< Alignment mask + NW = 1U << 29, ///< Not-write through caching + CD = 1U << 30, ///< Cache disable + PG = 1U << 31, ///< Paging +}; + +/*! \brief Control Register 4 + * + * \see [ISDMv3, 2.5 Control Registers](intel_manual_vol3.pdf#page=77) + */ +enum class CR4 : uint32_t { + VME = 1U << 0, ///< Virtual 8086 Mode Extensions + PVI = 1U << 1, ///< Protected-mode Virtual Interrupts + TSD = 1U << 2, ///< Time Stamp Disable + DE = 1U << 3, ///< Debugging Extensions + PSE = 1U << 4, ///< Page Size Extension + PAE = 1U << 5, ///< Physical Address Extension + MCE = 1U << 6, ///< Machine Check Exception + PGE = 1U << 7, ///< Page Global Enabled + PCE = 1U << 8, ///< Performance-Monitoring Counter enable + /// Operating system support for FXSAVE and FXRSTOR instructions + OSFXSR = 1U << 9, + OSXMMEXCPT = 1U << 10, ///< Operating System Support for Unmasked SIMD + ///< Floating-Point Exceptions + UMIP = 1U << 11, ///< User-Mode Instruction Prevention + VMXE = 1U << 13, ///< Virtual Machine Extensions Enable + SMXE = 1U << 14, ///< Safer Mode Extensions Enable + FSGSBASE = 1U << 16, ///< Enables the instructions RDFSBASE, RDGSBASE, + ///< WRFSBASE, and WRGSBASE. + PCIDE = 1U << 17, ///< PCID Enable + OSXSAVE = 1U << 18, ///< XSAVE and Processor Extended States Enable + SMEP = 1U << 20, ///< Supervisor Mode Execution Protection Enable + SMAP = 1U << 21, ///< Supervisor Mode Access Prevention Enable + PKE = 1U << 22, ///< Protection Key Enable +}; + +/*! \brief Access to the Control Register + * + * \see [ISDMv3, 2.5 Control Registers](intel_manual_vol3.pdf#page=73) + * \tparam id Control Register to access + */ +template +class CR { + public: + /*! \brief Read the value of the current Control Register + * + * \return Value stored in the CR + */ + static uintptr_t read(void) { + uintptr_t val; + asm volatile("mov %%cr%c1, %0" : "=r"(val) : "n"(id)); + return val; + } + + /*! \brief Write a value into the current Control Register + * + * \param value Value to write into the CR + */ + static void write(uintptr_t value) { + asm volatile("mov %0, %%cr%c1" : : "r"(value), "n"(id)); + } +}; +} // namespace Core diff --git a/kernel/arch/core_interrupt.h b/kernel/arch/core_interrupt.h new file mode 100644 index 0000000..eda8aa2 --- /dev/null +++ b/kernel/arch/core_interrupt.h @@ -0,0 +1,146 @@ +/*! \file + * \brief \ref Core::Interrupt "Interrupt control" and \ref + * Core::Interrupt::Vector "interrupt vector list" + */ + +#pragma once +#include "../types.h" + +namespace Core { +/*! \brief Exception and Interrupt control + * + * \see [ISDMv3, Chapter 6 Interrupt and Exception + * Handling](intel_manual_vol3.pdf#page=185) + */ +namespace Interrupt { + +/*! \brief Bit in `FLAGS` register corresponding to the current interrupt state + */ +constexpr uintptr_t FLAG_ENABLE = 1 << 9; + +/*! \brief List of used interrupt vectors. + * + * The exception vectors from `0` to `31` are reserved for traps, faults and + * aborts. Their behavior is different for each exception, some push an *error + * code*, some are not recoverable. + * + * The vectors from `32` to `255` are user defined interrupts. + * + * \see [ISDMv3, 6.15 Exception and Interrupt + * Reference](intel_manual_vol3.pdf#page=203) + */ +enum class Vector : uint8_t { + // Predefined Exceptions + DIVISON_BY_ZERO = + 0, ///< Divide-by-zero Error (at a `DIV`/`IDIV` instruction) + DEBUG = 1, ///< Debug exception + NON_MASKABLE_INTERRUPT = 2, ///< Non Maskable Interrupt + BREAKPOINT = 3, ///< Breakpoint exception (used for debugging) + OVERFLOW = 4, ///< Overflow exception (at `INTO` instruction) + BOUND_RANGE_EXCEEDED = + 5, ///< Bound Range Exceeded (at `BOUND` instruction) + INVALID_OPCODE = 6, ///< Opcode at Instruction Pointer is invalid (you + ///< probably shouldn't be here) + DEVICE_NOT_AVAILABLE = 7, ///< FPU/MMX/SSE instruction but corresponding + ///< extension not activated + DOUBLE_FAULT = 8, ///< Exception occurred while trying to call + ///< exception/interrupt handler + // Coprocessor Segment Overrun (Legacy) + INVALID_TSS = + 10, ///< Invalid Task State Segment selector (see error code for index) + SEGMENT_NOT_PRESENT = + 11, ///< Segment not available (see error code for selector index) + STACK_SEGMENT_FAULT = 12, ///< Stack segment not available or invalid (see + ///< error code for selector index) + GENERAL_PROTECTION_FAULT = + 13, ///< Operation not allowed (see error code for selector index) + PAGE_FAULT = 14, ///< Operation on Page (r/w/x) not allowed for current + ///< privilege (error code + `cr2`) + // reserved + FLOATING_POINT_EXCEPTION = 16, ///< x87 FPU error (at `WAIT`/`FWAIT`), + ///< accidentally \ref Core::CR0_NE set? + ALIGNMENT_CHECK = 17, ///< Unaligned memory access in userspace (Exception + ///< activated by \ref Core::CR0_AM) + MACHINE_CHECK = 18, ///< Model specific exception, check \ref Core::MSR, + ///< activated by \ref Core::CR4_MCE + SIMD_FP_EXCEPTION = + 19, ///< SSE/MMX error (if \ref Core::CR4_OSXMMEXCPT activated) + SECURITY_EXCEPTION = 31, + + // Interrupts + KEYBOARD = 33, ///< Keyboard interrupt (key press / release) + PANIC = 99, ///< Panic interrupt to stop CPU (default value for \ref IOAPIC + ///< devices) + TIMER = 32, ///< Periodic CPU local \ref LAPIC::Timer interrupt +}; +constexpr size_t VECTORS = 256; + +/*! \brief Check if interrupts are enabled on this CPU + * + * This is done by pushing the `FLAGS` register onto stack, + * reading it into a register and checking the corresponding bit. + * + * \return `true` if enabled, `false` if disabled + */ +inline bool isEnabled() { + uintptr_t out; + asm volatile( + "pushf\n\t" + "pop %0\n\t" + : "=r"(out) + : + : "memory"); + return (out & FLAG_ENABLE) != 0; +} + +/*! \brief Allow interrupts + * + * Enables interrupt handling by executing the instruction `sti`. + * Since this instruction is delayed by one cycle, an subsequent `nop` is + * executed (to ensure deterministic behavior, independent from the compiler + * generated code) + * + * A pending interrupt (i.e., those arriving while interrupts were disabled) + * will be delivered after re-enabling interrupts. + * + * \see [ISDMv2, Chapter 4. STI - Set Interrupt + * Flag](intel_manual_vol2.pdf#page=1297) + */ +inline void enable() { asm volatile("sti\n\t nop\n\t" : : : "memory"); } + +/*! \brief Forbid interrupts + * + * Prevents interrupt handling by executing the instruction `cli`. + * Will return the previous interrupt state. + * \return `true` if interrupts were enabled at the time of executing this + * function, `false` if they were already disabled. + * + * \see [ISDMv2, Chapter 3. CLI - Ckear Interrupt + * Flag](intel_manual_vol2.pdf#page=245) + */ +inline bool disable() { + bool enabled = isEnabled(); + asm volatile("cli\n\t" : : : "memory"); + + return enabled; +} + +/*! \brief Restore interrupt + * + * Restore the interrupt state to the state prior to calling \ref disable() by + * using its return value. + * + * \note This function will never disable interrupts, even if val is false! + * This function is designed to allow nested disabling and restoring of + * the interrupt state. + * + * \param val if set to `true`, interrupts will be enabled; nothing will happen + * on false. + */ +inline void restore(bool val) { + if (val) { + enable(); + } +} +} // namespace Interrupt +} // namespace Core diff --git a/kernel/arch/core_msr.h b/kernel/arch/core_msr.h new file mode 100644 index 0000000..a4d645b --- /dev/null +++ b/kernel/arch/core_msr.h @@ -0,0 +1,101 @@ +/*! \file + * \brief \ref Core::MSRs "Identifiers" for \ref Core::MSR "Model-Specific + * Register" + */ + +#pragma once +#include "../types.h" + +namespace Core { +/*! \brief Model-Specific Register Identifiers + * + * Selection of useful identifiers. + * + * \see [ISDMv4](intel_manual_vol4.pdf) + */ +enum class MSRs : uint32_t { + PLATFORM_INFO = + 0xce, ///< Platform information including bus frequency (Intel) + TSC_DEADLINE = 0x6e0, ///< Register for LAPIC::Timer Deadline mode + // Fast system calls + EFER = + 0xC0000080, ///< Extended Feature Enable Register, see Core::MSR_EFER + STAR = 0xC0000081, ///< eip (protected mode), ring 0 and 3 segment bases + LSTAR = 0xC0000082, ///< rip (long mode) + SFMASK = 0xC0000084, ///< lower 32 bit: flag mask, if bit is set + ///< corresponding rflag is cleared through syscall + // CPU local variables + FS_BASE = 0xC0000100, + GS_BASE = 0xC0000101, ///< Current GS base pointer + SHADOW_GS_BASE = 0xC0000102, ///< Usually called `MSR_KERNEL_GS_BASE` but + ///< this is misleading +}; + +/* \brief Important bits in Extended Feature Enable Register (EFER) + * + * \see [ISDMv3, 2.2.1 Extended Feature Enable + * Register](intel_manual_vol3.pdf#page=69) + * \see [AAPMv2, 3.1.7 Extended Feature Enable + * Register](amd64_manual_vol2.pdf#page=107) + */ +enum class MSR_EFER : uint32_t { + SCE = 1 << 0, ///< System Call Extensions + LME = 1 << 8, ///< Long mode enable + LMA = 1 << 10, ///< Long mode active + NXE = 1 << 11, ///< No-Execute Enable + SVME = 1 << 12, ///< Secure Virtual Machine Enable + LMSLE = 1 << 13, ///< Long Mode Segment Limit Enable + FFXSR = 1 << 14, ///< Fast `FXSAVE`/`FXRSTOR` instruction + TCE = 1 << 15, ///< Translation Cache Extension +}; + +/*! \brief Access to the Model-Specific Register (MSR) + * + * \see [ISDMv3, 9.4 Model-Specific Registers + * (MSRs)](intel_manual_vol3.pdf#page=319) + * \see [ISDMv4](intel_manual_vol4.pdf) + * \tparam id ID of the Model-Specific Register to access + */ +template +class MSR { + /*! \brief Helper to access low and high bits of a 64 bit value + * \internal + */ + union uint64_parts { + struct { + uint32_t low; + uint32_t high; + } __attribute__((packed)); + uint64_t value; + + explicit uint64_parts(uint64_t value = 0) : value(value) {} + }; + + public: + /*! \brief Read the value of the current MSR + * + * \return Value stored in the MSR + * + * \see [ISDMv2, Chapter 4. RDMSR - Read from Model Specific + * Register](intel_manual_vol2.pdf#page=1186) + */ + static uint64_t read() { + uint64_parts p; + asm volatile("rdmsr \n\t" : "=a"(p.low), "=d"(p.high) : "c"(id)); + return p.value; + } + + /*! \brief Write a value into the current MSR + * + * \param value Value to write into the MSR + * + * \see [ISDMv2, Chapter 5. WRMSR - Write to Model Specific + * Register](intel_manual_vol2.pdf#page=1912) + */ + static void write(uint64_t value) { + uint64_parts p(value); + asm volatile("wrmsr \n\t" : : "c"(id), "a"(p.low), "d"(p.high)); + } +}; + +} // namespace Core diff --git a/kernel/arch/core_ring.cc b/kernel/arch/core_ring.cc new file mode 100644 index 0000000..99b141b --- /dev/null +++ b/kernel/arch/core_ring.cc @@ -0,0 +1,17 @@ +#include "./core_ring.h" + +#include "./core_interrupt.h" +#include "./gdt.h" + +namespace Core { +namespace Ring { +[[gnu::noreturn]] +void switchToUsermode(void *stackpointer, void *kickoff, + void *kickoff_parameter) { + (void)stackpointer; + (void)kickoff; + (void)kickoff_parameter; + __builtin_unreachable(); +} +} // namespace Ring +} // namespace Core diff --git a/kernel/arch/core_ring.h b/kernel/arch/core_ring.h new file mode 100644 index 0000000..11e7d64 --- /dev/null +++ b/kernel/arch/core_ring.h @@ -0,0 +1,31 @@ + +#pragma once +#include "../types.h" + +namespace Core { +/*! \brief Protection Rings + */ +namespace Ring { + +/*! \brief Switch to Ring 3 + * + * \param stackpointer usermode stack pointer + * \param kickoff pointer to function in user mode + * \param kickoff_parameter put in register for 1. function parameter + */ +[[gnu::noreturn]] +void switchToUsermode(void *stackpointer, void *kickoff, + void *kickoff_parameter); + +/*! \brief Get current protection level + * + * \return current ring + */ +inline unsigned get() { + unsigned cs; + asm volatile("mov %%cs, %0\n\t" : "=r"(cs)::"memory"); + return cs & 0b11; // last bits define the ring +} + +} // namespace Ring +} // namespace Core diff --git a/kernel/arch/cpuid.h b/kernel/arch/cpuid.h new file mode 100644 index 0000000..37a5110 --- /dev/null +++ b/kernel/arch/cpuid.h @@ -0,0 +1,205 @@ +/*! \file + * \brief \ref CPUID queries information about the processor + */ +#pragma once +#include "../types.h" + +/*! \brief Query information about the processor + * + * \note This is an interface to the `cpuid` instruction, which can return + * information about the processor. It should therefor **not** be confused with + * functionality to + * \ref Core::getID() "retrieve the ID of the current CPU (core)"! + */ +namespace CPUID { + +/*! \brief Structure for register values returned by `cpuid` instruction + */ +union Reg { + struct { + uint32_t ebx, edx, ecx, eax; + }; + char value[16]; +}; + +enum Function { + HIGHEST_FUNCTION_PARAMETER = 0x0, ///< Maximum Input Value for Basic CPUID + ///< Information (in register `eax`) + MANUFACTURER_ID = 0x0, ///< CPU String (in register `ebx`, `ecx` and `edx`) + PROCESSOR_INFO = 0x1, ///< Version Information like Type, Family, Model (in + ///< register `eax`) + FEATURE_BITS = 0x1, ///< Feature Information (in register `ecx` and `edx`) + CACHE_INFORMATION = 0x2, ///< Cache and TLB Information + PROCESSOR_SERIAL_NUMBER = 0x3, ///< deprecated + HIGHEST_EXTENDED_FUNCTION = + 0x80000000, ///< Maximum Input Value for Extended Function CPUID (in + ///< register `eax`) + EXTENDED_PROCESSOR_INFO = 0x80000001, ///< Extended Processor Signature and + ///< Feature Bits (in register `eax`) + EXTENDED_FEATURE_BITS = 0x80000001, ///< Extended Feature Information (in + ///< register `ecx` and `edx`) + PROCESSOR_BRAND_STRING_1 = 0x80000002, ///< Processor Brand String (1/3) + PROCESSOR_BRAND_STRING_2 = 0x80000003, ///< Processor Brand String (2/3) + PROCESSOR_BRAND_STRING_3 = 0x80000004, ///< Processor Brand String (3/3) + ADVANCED_POWER_MANAGEMENT = + 0x80000007, ///< Advanced Power Management (with Invariant TSC in + ///< register `edx`) + ADDRESS_SIZES = + 0x80000008, ///< Linear/Physical Address size (in register `eax`) +}; + +/*! \brief Get CPU identification and feature information + * + * \param eax Requested feature + * \return Register values filled by instruction `cpuid` for the requested + * feature + * + * \see [ISDMv2, Chapter 3. CPUID - CPU + * Identification](intel_manual_vol2.pdf#page=292) + */ +inline Reg get(Function eax) { + Reg r; + asm volatile("cpuid \n\t" + : "=a"(r.eax), "=b"(r.ebx), "=c"(r.ecx), "=d"(r.edx) + : "0"(eax)); + return r; +} + +enum FeatureECX { + FEATURE_SSE3 = 1 << 0, ///< Prescott New Instructions-SSE3 (PNI) + FEATURE_PCLMUL = 1 << 1, ///< Carry-less Multiplication + FEATURE_DTES64 = 1 << 2, ///< 64-bit debug store (edx bit 21) + FEATURE_MONITOR = 1 << 3, ///< MONITOR and MWAIT instructions (SSE3) + FEATURE_DS_CPL = 1 << 4, ///< CPL qualified debug store + FEATURE_VMX = 1 << 5, ///< Virtual Machine eXtensions + FEATURE_SMX = 1 << 6, ///< Safer Mode Extensions (LaGrande) + FEATURE_EST = 1 << 7, ///< Enhanced SpeedStep + FEATURE_TM2 = 1 << 8, ///< Thermal Monitor 2 + FEATURE_SSSE3 = 1 << 9, ///< Supplemental SSE3 instructions + FEATURE_CID = 1 << 10, ///< L1 Context ID + FEATURE_SDBG = 1 << 11, ///< Silicon Debug interface + FEATURE_FMA = 1 << 12, ///< Fused multiply-add (FMA3) + FEATURE_CX16 = 1 << 13, ///< CMPXCHG16B instruction + FEATURE_ETPRD = 1 << 14, ///< Can disable sending task priority messages + FEATURE_PDCM = 1 << 15, ///< Perfmon & debug capability + FEATURE_PCIDE = 1 << 17, ///< Process context identifiers (CR4 bit 17) + FEATURE_DCA = 1 << 18, ///< Direct cache access for DMA writes + FEATURE_SSE4_1 = 1 << 19, ///< SSE4.1 instructions + FEATURE_SSE4_2 = 1 << 20, ///< SSE4.2 instructions + FEATURE_X2APIC = 1 << 21, ///< x2APIC + FEATURE_MOVBE = 1 << 22, ///< MOVBE instruction (big-endian) + FEATURE_POPCNT = 1 << 23, ///< POPCNT instruction + FEATURE_TSC_DEADLINE = 1 << 24, ///< APIC implements one-shot operation + ///< using a TSC deadline value + FEATURE_AES = 1 << 25, ///< AES instruction set + FEATURE_XSAVE = 1 << 26, ///< XSAVE, XRESTOR, XSETBV, XGETBV + FEATURE_OSXSAVE = 1 << 27, ///< XSAVE enabled by OS + FEATURE_AVX = 1 << 28, ///< Advanced Vector Extensions + FEATURE_F16C = 1 << 29, ///< F16C (half-precision) FP feature + FEATURE_RDRND = + 1 << 30, ///< RDRAND (on-chip random number generator) feature + FEATURE_HYPERVISOR = + 1 << 31 ///< Hypervisor present (always zero on physical CPUs) +}; + +enum FeatureEDX { + FEATURE_FPU = 1 << 0, ///< Onboard x87 FPU + FEATURE_VME = + 1 << 1, ///< Virtual 8086 mode extensions (such as VIF, VIP, PIV) + FEATURE_DE = 1 << 2, ///< Debugging extensions (CR4 bit 3) + FEATURE_PSE = 1 << 3, ///< Page Size Extension + FEATURE_TSC = 1 << 4, ///< Time Stamp Counter + FEATURE_MSR = 1 << 5, ///< Model-specific registers + FEATURE_PAE = 1 << 6, ///< Physical Address Extension + FEATURE_MCE = 1 << 7, ///< Machine Check Exception + FEATURE_CX8 = 1 << 8, ///< CMPXCHG8 (compare-and-swap) instruction + FEATURE_APIC = + 1 << 9, ///< Onboard Advanced Programmable Interrupt Controller + FEATURE_SEP = 1 << 11, ///< SYSENTER and SYSEXIT instructions + FEATURE_MTRR = 1 << 12, ///< Memory Type Range Registers + FEATURE_PGE = 1 << 13, ///< Page Global Enable bit in CR4 + FEATURE_MCA = 1 << 14, ///< Machine check architecture + FEATURE_CMOV = 1 << 15, ///< Conditional move and FCMOV instructions + FEATURE_PAT = 1 << 16, ///< Page Attribute Table + FEATURE_PSE36 = 1 << 17, ///< 36-bit page size extension + FEATURE_PSN = 1 << 18, ///< Processor Serial Number + FEATURE_CLF = 1 << 19, ///< CLFLUSH instruction (SSE2) + FEATURE_DTES = 1 << 21, ///< Debug store: save trace of executed jumps + FEATURE_ACPI = 1 << 22, ///< Onboard thermal control MSRs for ACPI + FEATURE_MMX = 1 << 23, ///< MMX instructions + FEATURE_FXSR = 1 << 24, ///< FXSAVE, FXRESTOR instructions, CR4 bit 9 + FEATURE_SSE = + 1 << 25, ///< SSE instructions (a.k.a. Katmai New Instructions) + FEATURE_SSE2 = 1 << 26, ///< SSE2 instructions + FEATURE_SS = 1 << 27, ///< CPU cache implements self-snoop + FEATURE_HTT = 1 << 28, ///< Hyper-threading + FEATURE_TM1 = + 1 << 29, ///< Thermal monitor automatically limits temperature + FEATURE_IA64 = 1 << 30, ///< IA64 processor emulating x86 + FEATURE_PBE = + 1 << 31 ///< Pending Break Enable (PBE# pin) wakeup capability +}; + +enum ExtendedFeatureEDX { + EXTENDED_FEATURE_FPU = 1 << 0, ///< Onboard x87 FPU + EXTENDED_FEATURE_VME = + 1 << 1, ///< Virtual 8086 mode extensions (such as VIF, VIP, PIV) + EXTENDED_FEATURE_DE = 1 << 2, ///< Debugging extensions (CR4 bit 3) + EXTENDED_FEATURE_PSE = 1 << 3, ///< Page Size Extension + EXTENDED_FEATURE_TSC = 1 << 4, ///< Time Stamp Counter + EXTENDED_FEATURE_MSR = 1 << 5, ///< Model-specific registers + EXTENDED_FEATURE_PAE = 1 << 6, ///< Physical Address Extension + EXTENDED_FEATURE_MCE = 1 << 7, ///< Machine Check Exception + EXTENDED_FEATURE_CX8 = 1 << 8, ///< CMPXCHG8 (compare-and-swap) instruction + EXTENDED_FEATURE_APIC = + 1 << 9, ///< Onboard Advanced Programmable Interrupt Controller + EXTENDED_FEATURE_SYSCALL = 1 << 11, ///< SYSCALL and SYSRET instructions + EXTENDED_FEATURE_MTRR = 1 << 12, ///< Memory Type Range Registers + EXTENDED_FEATURE_PGE = 1 << 13, ///< Page Global Enable bit in CR4 + EXTENDED_FEATURE_MCA = 1 << 14, ///< Machine check architecture + EXTENDED_FEATURE_CMOV = 1 + << 15, ///< Conditional move and FCMOV instructions + EXTENDED_FEATURE_PAT = 1 << 16, ///< Page Attribute Table + EXTENDED_FEATURE_PSE36 = 1 << 17, ///< 36-bit page size extension + EXTENDED_FEATURE_MP = 1 << 19, ///< Multiprocessor Capable + EXTENDED_FEATURE_NX = 1 << 20, ///< Non-executable bit + EXTENDED_FEATURE_MMXEXT = 1 << 22, ///< extended MMX instructions + EXTENDED_FEATURE_MMX = 1 << 23, ///< MMX instructions + EXTENDED_FEATURE_FXSR = + 1 << 24, ///< FXSAVE, FXRESTOR instructions, CR4 bit 9 + EXTENDED_FEATURE_FXSR_OPT = 1 << 25, ///< FXSAVE, FXRESTOR optimizations + EXTENDED_FEATURE_PDPE1GB = 1 << 26, ///< Gibibyte Pages + EXTENDED_FEATURE_RDTSCP = 1 << 27, ///< CPU cache implements self-snoop + EXTENDED_FEATURE_LM = 1 << 29, ///< Long Mode (x64) + EXTENDED_FEATURE_3DNOWEXT = 1 << 30, ///< Extended 3DNow! instructions + EXTENDED_FEATURE_3DNOW = 1 << 31 ///< 3DNow! instructions +}; + +/*! \brief Check if feature is provided by this system + * + * \param feature Feature to test + * \return `true` if available, `false` otherwise + */ +inline bool has(enum FeatureECX feature) { + return (get(FEATURE_BITS).ecx & feature) != 0; +} + +/*! \brief Check if feature is provided by this system + * + * \param feature Feature to test + * \return `true` if available, `false` otherwise + */ +inline bool has(enum FeatureEDX feature) { + return (get(FEATURE_BITS).edx & feature) != 0; +} + +/*! \brief Check if feature is provided by this system + * + * \param feature Extended feature to test + * \return `true` if available, `false` if either feature or extended features + * are unavailable + */ +inline bool has(enum ExtendedFeatureEDX feature) { + return (get(EXTENDED_FEATURE_BITS).edx & feature) != 0; +} +} // namespace CPUID diff --git a/kernel/arch/gdt.cc b/kernel/arch/gdt.cc new file mode 100644 index 0000000..4884226 --- /dev/null +++ b/kernel/arch/gdt.cc @@ -0,0 +1,36 @@ +#include "gdt.h" + +#include "core.h" + +namespace GDT { + +// The static 32-bit Global Descriptor Table (GDT) +alignas(16) constinit SegmentDescriptor protected_mode[] = { + // Null descriptor + {}, + + // Global code segment von 0-4GB + SegmentDescriptor::Segment(0, UINT32_MAX, true, 0, Size::Bit32), + + // Global data segment von 0-4GB + SegmentDescriptor::Segment(0, UINT32_MAX, false, 0, Size::Bit32), +}; +extern "C" constexpr Pointer gdt_protected_mode_pointer(protected_mode); + +// The static 64-bit Global Descriptor Table (GDT) +// \see [ISDMv3 3.2.4 Segmentation in IA-32e +// Mode](intel_manual_vol3.pdf#page=91) +alignas(16) constinit SegmentDescriptor long_mode[] = { + // Null descriptor + SegmentDescriptor::Null(), + + // Global code segment + SegmentDescriptor::Segment64(true, 0), + + // Global data segment + SegmentDescriptor::Segment64(false, 0), + +}; +extern "C" constexpr Pointer gdt_long_mode_pointer(long_mode); + +} // namespace GDT diff --git a/kernel/arch/gdt.h b/kernel/arch/gdt.h new file mode 100644 index 0000000..35aabe3 --- /dev/null +++ b/kernel/arch/gdt.h @@ -0,0 +1,203 @@ +/*! \file + * \brief The \ref GDT "Global Descriptor Table (GDT)". + * \defgroup memory Memory management + */ + +#pragma once +#include "../types.h" + +/*! \brief Abstracts the GDT that, primarily, contains descriptors to memory + * segments. + * \ingroup memory + * + * The GDT is a table that primarily contains segment descriptors. Segment + * descriptors has a size of 8 Bytes and contains the size, position, access + * rights, and purpose of such a segment. Unlike the LDT, the GDT is shared + * between all processes and may contain TSS and LDT descriptors. For the + * kernel, the first entry is required to be a null descriptor and the code and + * data segments. To support user-mode processes, additional TSS, code, and data + * segments for ring 3 must be added. + * + * The base address and size of the GDT are written to the GDTR register during + * boot (via. `lgdt`). + * + * \see [ISDMv3, 2.4.1; Global Descriptor Table Register + * (GDTR)](intel_manual_vol3.pdf#page=72) + * \see [ISDMv3, 3.5.1; Segment + * Descriptor Tables](intel_manual_vol3.pdf#page=99) + */ +namespace GDT { + +enum class Segments { + Null = 0, + KernelCode, + KernelData, +}; + +/*! \brief Unit of the segment limit + */ +enum class Granularity { + Bytes = 0, ///< Segment limit in Bytes + Pages = 1 ///< Segment limit in blocks of 4 Kilobytes +}; + +/*! \brief Descriptor type */ +enum class DescriptorType { + System = 0, ///< entry is a system segment + CodeData = 1, ///< entry is a code/data segment +}; + +/*! \brief Address width + */ +enum class Size { + Bit16 = 0, ///< 16-bit (D/B = 0, L = 0) + Bit32 = 2, ///< 32-bit (D/B = 1, L = 0) + Bit64 = 1, ///< 64-bit (D/B = 0, L = 1) +}; + +/*! \brief Type flags for used descriptor types + */ +enum class TypeFlags : uint64_t { + DataRW = 0b0010ULL, ///< Data rw, not expanding down + CodeRX = 0b1010ULL, ///< Code rx, non-conforming +}; + +/*! \brief Describes the structure of segment descriptors + * + * A data structure that contains size, position, access rights, and purpose of + * any segment. Segment descriptors are used in both the GDT, as well as in + * LDTs. + * + * \see [ISDMv3, 3.4.5; Segment Descriptors](intel_manual_vol3.pdf#page=95) + * \see [AAPMv2, 4.7 Legacy Segment Descriptors](amd64_manual_vol2.pdf#page=132) + * \see [AAPMv2, 4.8 Long-Mode Segment + * Descriptors](amd64_manual_vol2.pdf#page=140) + */ +union SegmentDescriptor { + // Universally valid values (shared across all segment types) + struct { + uint64_t limit_low : 16; ///< Least-significant bits of segment size + ///< (influenced by granularity!) + uint64_t base_low : 24; ///< Least-significant bits of base address + uint64_t type : 4; ///< Meaning of those 4 bits depends on + ///< descriptor_type below + DescriptorType + descriptor_type : 1; ///< Descriptor type (influences the + ///< meaning of the 3 bits above) + uint64_t privilege_level : 2; ///< Ring for this segment + bool present : 1; ///< Entry is valid iff set to `true` + uint64_t limit_high : 4; ///< Most-significant bits of segment size + bool available : 1; ///< Bit which can be used for other purposes (in + ///< software) + uint64_t custom : 2; ///< Meaning of those 2 bits relate to + ///< descriptor_type and type + Granularity granularity : 1; ///< Unit used as granularity for the + ///< segment limit + uint64_t base_high : 8; ///< most-significant bits of base address + } __attribute__((packed)); + + uint64_t value; ///!< Merged value + + /*! \brief Explicitly constructs a null descriptor. + */ + consteval static SegmentDescriptor Null() { + return SegmentDescriptor{ + .value = 0, + }; + } + + /*! \brief Constructs a code/data segment descriptor. + * \param base Base Address of segment + * \param limit Size of segment + * \param code Code or data segment + * \param ring Privilege level + * \param size Address width + */ + consteval static SegmentDescriptor Segment(uintptr_t base, uint32_t limit, + bool code, uint64_t ring, + Size size) { + return SegmentDescriptor{ + .limit_low = limit >> (limit > 0xFFFFF ? 12 : 0) & 0xFFFF, + .base_low = base & 0xFFFFFF, + .type = code ? uint64_t(TypeFlags::CodeRX) + : uint64_t(TypeFlags::DataRW), + .descriptor_type = DescriptorType::CodeData, + .privilege_level = ring, + .present = true, + .limit_high = + (limit > 0xFFFFF ? (limit >> 28) : (limit >> 16)) & 0xF, + .available = false, + .custom = uint64_t(size), + .granularity = + limit > 0xFFFFF ? Granularity::Pages : Granularity::Bytes, + .base_high = (base >> 24) & 0xFF, + }; + } + + /*! \brief Constructs a 64bit code/data segment descriptor. + * \param code Code or data segment + * \param ring Privilege level + */ + consteval static SegmentDescriptor Segment64(bool code, int ring) { + return SegmentDescriptor::Segment(0, 0, code, ring, Size::Bit64); + } + +} __attribute__((packed)); + +static_assert(sizeof(SegmentDescriptor) == 8, + "GDT::SegmentDescriptor has wrong size"); + +/*! \brief Structure that describes a GDT Pointer (aka GDT Descriptor) + * + * It contains both the length (in bytes) of the GDT (minus 1 byte) and the + * pointer to the GDT. The pointer to the GDT can be loaded using the + * instruction `lgdt`. + * + * \note As Intel uses little endian for representing multi-byte values, the + * GDT::Pointer structure can be used for 16, 32, and 64 bit descriptor tables: + * \verbatim + * | 16 bit | 16 bit | 16 bit | 16 bit | 16 bit | + * +--------+---------------------------------------+ + * Pointer | limit | base (up to 64 bit) | + * +--------+---------+---------+---------+---------+ + * | used for 16 bit | ignored... | + * | used for 32 bit | ignored... | + * | used for 64 bit | + * \endverbatim + * + * \see [ISDMv3, Figure 2-6; Memory Management + * Registers](intel_manual_vol3.pdf#page=72) + */ +struct Pointer { + uint16_t limit; //!< GDT size in bytes (minus 1 byte) + void* base; //!< GDT base address + + /*! \brief Constructor (automatic length) + * \param desc Array of GDT segment descriptors -- must be defined in the + * same module! + */ + template + explicit constexpr Pointer(const T (&desc)[LEN]) + : limit((LEN * sizeof(T)) - 1), base(const_cast(desc)) {} + + /*! \brief Constructor + * \param desc Address of the GDT segment descriptors + * \param len Number of entries + */ + consteval Pointer(void* desc, size_t len) + : limit((len * sizeof(SegmentDescriptor)) - 1), base(desc) {} + + /*! \brief Set an address + * \note On change, `lgdt` must be executed again + * \param desc Address of the GDT segment descriptors + * \param len Number of entries + */ + constexpr void set(void* desc, size_t len) { + limit = (len * sizeof(SegmentDescriptor)) - 1; + base = desc; + } +} __attribute__((packed)); + +static_assert(sizeof(Pointer) == 10, "GDT::Pointer has wrong size"); + +} // namespace GDT diff --git a/kernel/arch/idt.cc b/kernel/arch/idt.cc new file mode 100644 index 0000000..22c21ba --- /dev/null +++ b/kernel/arch/idt.cc @@ -0,0 +1,36 @@ +#include "idt.h" + +#include "core_interrupt.h" + +namespace IDT { + +// Interrupt Descriptor Table, 8 Byte aligned +constinit struct InterruptDescriptor idt[256] = {}; + +// Struct used for loading (the address of) the Interrupt Descriptor Table into +// the IDT-Register +struct Register { + uint16_t limit; // Address of the last valid byte (relative to base) + struct InterruptDescriptor* base; + explicit Register(uint8_t max = 255) { + limit = + (max + static_cast(1)) * sizeof(InterruptDescriptor) - 1; + base = idt; + } +} __attribute__((packed)); + +static_assert(sizeof(InterruptDescriptor) == 16, + "IDT::InterruptDescriptor has wrong size"); +static_assert(sizeof(Register) == 10, "IDT::Register has wrong size"); +static_assert(alignof(decltype(idt)) % 8 == 0, "IDT must be 8 byte aligned!"); + +void load() { + // Create structure required for writing to idtr and load via lidt + Register idtr(Core::Interrupt::VECTORS - 1); + asm volatile("lidt %0\n\t" ::"m"(idtr)); +} + +void set(Core::Interrupt::Vector vector, InterruptDescriptor descriptor) { + idt[(uint8_t)vector] = descriptor; +} +} // namespace IDT diff --git a/kernel/arch/idt.h b/kernel/arch/idt.h new file mode 100644 index 0000000..b4b5c5f --- /dev/null +++ b/kernel/arch/idt.h @@ -0,0 +1,233 @@ +/*! \file + * \brief \ref IDT "Interrupt Descriptor Table (IDT)" containing the entry + * points for interrupt handling. + */ + +#pragma once +#include "../types.h" +#include "core_interrupt.h" +#include "object/outputstream.h" + +/*! \brief Preserved interrupt context + * + * After an interrupt was triggered, the core first saves the basic context + * (current code- & stack segment, instruction & stack pointer and the status + * flags register) and looks up the handling function for the vector using the + * \ref IDT. No other registers are saved or restored automatically. It is the + * handlers (our) job to save and restore all modified registers. However, most + * handlers in StuBS are implemented directly in C++ utilizing the `interrupt` + * attribute: The compiler treats all modified registers as callee-saved, which + * saves us a lot of work, but prevents us from knowing the exact contents of + * each regiser (we don't know if/when the compiler modified it). `interrupt` + * functions receive up to two parameters: A pointer to this /ref + * InterruptContext and, depending on the interrupt, an error code, which is + * also pushed onto the stack by the CPU. Contrary to "normal" functions, the + * compiler will return using the `iret` instruction. + */ +struct InterruptContext { + // Context saved by CPU + // uintptr_t error_code; ///< Error Code + uintptr_t ip; ///< Instruction Pointer (at interrupt) + uintptr_t cs : 16; ///< Code segment (in case of a ring switch it is the + ///< segment of the user mode) + uintptr_t : 0; ///< Alignment (due to 16 bit code segment) + uintptr_t flags; ///< Status flags register + uintptr_t sp; ///< Stack pointer (at interrupt) + uintptr_t ss : 16; ///< Stack segment (in case of a ring switch it is the + ///< segment of the user mode) + uintptr_t : 0; ///< Alignment (due to 16 bit stack segment) +} __attribute__((packed)); +static_assert(sizeof(InterruptContext) == 5 * 8, + "InterruptContext has wrong size"); + +/// Page fault error codes +struct PageFaultError { + uint64_t present : 1; + uint64_t write : 1; + uint64_t user : 1; + uint64_t reserved : 1; + uint64_t ifetch : 1; + uint64_t : 59; // padding to 64 bits + explicit PageFaultError(uint64_t error) { + *reinterpret_cast(this) = error; + } + friend OutputStream &operator<<(OutputStream &os, + const PageFaultError &error) { + os << "PageFaultError { present: " << error.present + << ", write: " << error.write << ", user: " << error.user + << ", reserved: " << error.reserved << ", ifetch: " << error.ifetch + << " }"; + return os; + } +} __attribute__((packed)); + +/*! \brief "Interrupt Descriptor Table (IDT) + * \ingroup interrupts + * + * \see [ISDMv3 6.14 Exception and Interrupt Handling in 64-bit + * Mode](intel_manual_vol3.pdf#page=200) + */ +namespace IDT { +/*! \brief Gate types + * + * \see [ISDMv3 3.5 System Descriptor Types](intel_manual_vol3.pdf#page=99) + */ +enum Gate { + GATE_INT = 0x6, ///< Interrupt Gate (CPU disables interrupts unpon entry) + GATE_TRAP = 0x7, ///< Trap Gate (interrupts remain enabled unpon entry) +}; + +/*! \brief Segment type + * + * \see [ISDMv3 3.5 System Descriptor Types](intel_manual_vol3.pdf#page=99) + */ +enum GateSize { + GATE_SIZE_16 = 0, ///< 16 bit + GATE_SIZE_32 = 1, ///< 32 bit + GATE_SIZE_64 = 1, ///< 64 bit +}; + +/*! \brief Descriptor Privilege Level + */ +enum DPL { + DPL_KERNEL = 0, ///< Ring 0 / Kernel mode + /* DPLs 1 and 2 are unused */ + DPL_USER = 3, ///< Ring 3 / User mode +}; + +/*! \brief Interrupt handler that returns after execution (trap/fault). + */ +using ReturningHandler = void (*)(InterruptContext *); + +/*! \brief Interrupt handler that returns after execution (trap/fault) and + * receives an error code. + */ +using ReturningHandlerWithError = void (*)(InterruptContext *, uint64_t); + +/*! \brief Interrupt handler that does **not** return after execution (abort). + */ +using DivergingHandler = void (*)(InterruptContext *); + +/*! \brief Interrupt handler that does **not** return after execution (abort) + * and receives an error code. + */ +using DivergingHandlerWithError = void (*)(InterruptContext *, uint64_t); + +/*! \brief Interrupt Descriptor stored in the Interrupt-Descriptor Table (IDT) + */ +struct alignas(8) InterruptDescriptor { + uint16_t address_low; ///< lower interrupt function offset + uint16_t selector; ///< code segment selector in GDT or LDT + union { + struct { + uint8_t ist : 3; ///< Interrupt Stack Index + uint8_t : 5; ///< unused, has to be 0 + Gate type : 3; ///< gate type + GateSize size : 1; ///< gate size + uint8_t : 1; ///< unused, has to be 0 + DPL dpl : 2; ///< descriptor privilege level + bool present : 1; ///< present: 1 for interrupts + } __attribute__((packed)); + uint16_t flags; + }; + uint64_t address_high : 48; ///< higher interrupt function offset + uint64_t : 0; ///< fill until aligned with 64 bit + + /*! \brief Create a non-present interrupt descriptor. + */ + InterruptDescriptor() = default; + + /*! \brief Create an interrupt descriptor. + * + * + * \param handler Entry point for interrupt handling + * \param ist Stack index from the TSS for the interrupt + * handler. Set to 0 to use current stack. + * \param dpl Permissions required for enter this interrupt handler + * (kernel- or user space) + */ + InterruptDescriptor(uintptr_t handler, uint8_t ist, DPL dpl) + : address_low(handler & 0xffff), + selector(8), // XXX: This should come from `Segments` + ist(ist), + type(GATE_INT), + size(GATE_SIZE_64), + dpl(dpl), + present(true), + address_high((handler >> 16) & 0xffffffffffff) {} + + /*! \brief Create an interrupt descriptor for a handler that does return + * (trap/fault). + * + * \param handler Entry point for interrupt handling + * \param ist Stack index from the TSS for the interrupt + * handler. Set to 0 to use current stack. + * \param dpl Permissions required for enter this interrupt handler + * (kernel- or user space) + */ + static InterruptDescriptor Returning(ReturningHandler handler, + uint8_t ist = 0, + DPL dpl = DPL_KERNEL) { + return {reinterpret_cast(handler), ist, dpl}; + } + + /*! \brief Create an interrupt descriptor for a handler that does return + * (traps/fault) and receives an error code. + * + * + * \param handler Entry point for interrupt handling + * \param ist Stack index from the TSS for the interrupt + * handler. Set to 0 to use current stack. + * \param dpl Permissions required for enter this interrupt handler + * (kernel- or user space) + */ + static InterruptDescriptor ReturningWithError( + ReturningHandlerWithError handler, uint8_t ist = 0, + DPL dpl = DPL_KERNEL) { + return {reinterpret_cast(handler), ist, dpl}; + } + + /*! \brief Create an interrupt descriptor for a handler that does **not** + * return (abort). + * + * + * \param handler Entry point for interrupt handling + * \param ist Stack index from the TSS for the interrupt + * handler. Set to 0 to use current stack. + * \param dpl Permissions required for enter this interrupt handler + * (kernel- or user space) + */ + static InterruptDescriptor Diverging(DivergingHandler handler, + uint8_t ist = 0, + DPL dpl = DPL_KERNEL) { + return {reinterpret_cast(handler), ist, dpl}; + } + + /*! \brief Create an interrupt descriptor for a handler that does **not** + * return (abort) and receives an error code. + * + * + * \param handler Entry point for interrupt handling + * \param ist Stack index from the TSS for the interrupt + * handler. Set to 0 to use current stack. + * \param dpl Permissions required for enter this interrupt handler + * (kernel- or user space) + */ + static InterruptDescriptor DivergingWithError( + DivergingHandlerWithError handler, uint8_t ist = 0, + DPL dpl = DPL_KERNEL) { + return {reinterpret_cast(handler), ist, dpl}; + } + +} __attribute__((packed)); +static_assert(sizeof(InterruptDescriptor) == 16, + "IDT::InterruptDescriptor has wrong size"); + +/*! \brief Load the IDT's address and size into the IDT-Register via `idtr`. + */ +void load(); + +/*! \brief Set the idt entry for the given interrupt vector. + */ +void set(Core::Interrupt::Vector vector, InterruptDescriptor descriptor); +} // namespace IDT diff --git a/kernel/arch/ioapic.cc b/kernel/arch/ioapic.cc new file mode 100644 index 0000000..f01a732 --- /dev/null +++ b/kernel/arch/ioapic.cc @@ -0,0 +1,123 @@ +#include "ioapic.h" + +#include "../debug/assert.h" +#include "apic.h" +#include "core.h" + +namespace IOAPIC { +/*! \brief IOAPIC registers memory mapped into the CPU's address space. + * + * Access to the actual IOAPIC registers can be obtained by performing the + * following steps: + * 1. Write the number of the IOAPIC register to the address stored in + * `IOREGSEL_REG` + * 2. Read the value from / write the value to the address referred to by + * `IOWIN_REG`. + * + * \see [IO-APIC manual](intel_ioapic.pdf#page=8) + */ +volatile Index *IOREGSEL_REG = reinterpret_cast(0xfec00000); +/// \copydoc IOREGSEL_REG +volatile Register *IOWIN_REG = + reinterpret_cast(0xfec00010); + +// IOAPIC manual, p. 8 +const Index IOAPICID_IDX = 0x00; +const Index IOREDTBL_IDX = 0x10; + +const uint8_t slot_max = 24; + +// Helper function that reads a single register +static Register read(Index reg) { + *IOREGSEL_REG = reg; + Register value = *IOWIN_REG; + return value; +} + +// Helper function that writes a single register +static void write(Index reg, Register value) { + *IOREGSEL_REG = reg; + *IOWIN_REG = value; +} + +// Helper function that reads an entry (= reads from TWO registers) from the +// redirection table +static RedirectionTableEntry getRedirectionTableEntry(uint8_t slot) { + assert(slot < slot_max); + return RedirectionTableEntry(read(IOREDTBL_IDX + 2 * slot + 0), + read(IOREDTBL_IDX + 2 * slot + 1)); +} +// Helper function that writes an entry (= writes to TWO registers) to the +// redirection table +static void setRedirectionTableEntry(uint8_t slot, RedirectionTableEntry rt) { + assert(slot < slot_max); + write(IOREDTBL_IDX + 2 * slot + 0, rt.value_low); + write(IOREDTBL_IDX + 2 * slot + 1, rt.value_high); +} + +static void setID(uint8_t id) { + Identification reg(read(IOAPICID_IDX)); + reg.id = id; + write(IOAPICID_IDX, reg.value); +} + +void init() { + // optional: + IOREGSEL_REG = reinterpret_cast(APIC::getIOAPICAddress()); + IOWIN_REG = + reinterpret_cast(APIC::getIOAPICAddress() + 0x10); + + // set 4-bit ID to correct IO-APIC value, determined at startup + setID(APIC::getIOAPICID()); + + for (uint8_t i = 0; i < slot_max; ++i) { + RedirectionTableEntry rt = getRedirectionTableEntry(i); + + /* The old solution used 0xff as `destination` here, but the Intel + * manual (3A, 10.6.2.2 - Logical Destination Mode) states the + * following: "For both configurations of logical destination mode, when + * combined with lowest priority delivery mode, software is responsible + * for ensuring that all of the local APICs included in or addressed by + * the IPI or I/O subsystem interrupt are present and enabled to receive + * the interrupt." More recent processors assume the correctness of the + * value written to `destination`, and, therefore, will try to redirect + * the interrupt to non-existing LAPIC if misconfigured and wait for + * response. + */ + rt.destination = 1; + rt.vector = static_cast(Core::Interrupt::Vector::PANIC); + rt.delivery_mode = DeliveryMode::LOWEST_PRIORITY; + rt.destination_mode = DestinationMode::LOGICAL; + rt.polarity = Polarity::HIGH; + rt.trigger_mode = TriggerMode::EDGE; + rt.interrupt_mask = InterruptMask::MASKED; + setRedirectionTableEntry(i, rt); + } +} + +void config(uint8_t slot, Core::Interrupt::Vector vector, + TriggerMode trigger_mode, Polarity polarity) { + RedirectionTableEntry rt = getRedirectionTableEntry(slot); + rt.vector = static_cast(vector); + rt.polarity = polarity; + rt.trigger_mode = trigger_mode; + setRedirectionTableEntry(slot, rt); +} + +void allow(uint8_t slot) { + RedirectionTableEntry rt = getRedirectionTableEntry(slot); + rt.interrupt_mask = InterruptMask::UNMASKED; + setRedirectionTableEntry(slot, rt); +} + +void forbid(uint8_t slot) { + RedirectionTableEntry rt = getRedirectionTableEntry(slot); + rt.interrupt_mask = InterruptMask::MASKED; + setRedirectionTableEntry(slot, rt); +} + +bool status(uint8_t slot) { + RedirectionTableEntry rt = getRedirectionTableEntry(slot); + return rt.interrupt_mask == InterruptMask::UNMASKED; +} +} // namespace IOAPIC diff --git a/kernel/arch/ioapic.h b/kernel/arch/ioapic.h new file mode 100644 index 0000000..53aabb1 --- /dev/null +++ b/kernel/arch/ioapic.h @@ -0,0 +1,76 @@ +/*! \file + * \brief \ref IOAPIC abstracts the access to the I/O \ref APIC + */ + +#pragma once +#include "../types.h" +#include "core_interrupt.h" +#include "ioapic_registers.h" + +/*! \brief Abstraction of the I/O APIC that is used for management of external + * interrupts. + * \ingroup interrupts + * + * The I/O APIC's Core component is the IO-redirection table. This table is + * used to configure a flexible mapping between the interrupt number and the + * external interruption. Entries within this table have a width of 64 bit. For + * convenience, the union \ref IOAPIC::RedirectionTableEntry should be used for + * modifying these tables (see file `ioapic_registers.h` for details). + */ + +namespace IOAPIC { +/*! \brief Initializes the I/O APIC. + * + * This function will initialize the I/O APIC by initializing the + * IO-redirection table with sane default values. The default interrupt-vector + * number is chosen such that, in case the interrupt is issued, the panic + * handler is executed. In the beginning, all external interrupts are disabled + * within the I/O APIC. Apart from the redirection table, the `APICID` (read + * from the system description tables during boot) needs to be written to the + * `IOAPICID` register (see \ref APIC::getIOAPICID() ) + * + */ +void init(); + +/*! \brief Creates a mapping between an interrupt vector and an external +interrupt. +* +* \param slot Number of the slot (i.e., the external interrupt) to +configure. +* \param vector Number of the interrupt vector that will be issued for +the external interrupt. +* \param trigger_mode Edge or level triggered interrupt signaling +(level-triggered interrupts required for the optional serial interface) +* \param polarity Polarity of the interrupt signaling (active high or +active low) +* +*/ +void config(uint8_t slot, Core::Interrupt::Vector vector, + TriggerMode trigger_mode = TriggerMode::EDGE, + Polarity polarity = Polarity::HIGH); + +/*! \brief Enables the redirection of particular external interrupts to the + * CPU(s). + * + * To fully enable interrupt handling, the interrupts must be enabled for every + * CPU (e.g., by calling + * \ref Core::Interrupt::enable() in main). + * + * \param slot Number of the external interrupt that should be enabled. + * + */ +void allow(uint8_t slot); + +/*! \brief Selectively masks external interrupts by slot number. + * \param slot Slot number of the interrupt to be disabled. + * + */ +void forbid(uint8_t slot); + +/*! \brief Check whether an external interrupt source is masked. + * \param slot Slot number of the interrupt to be checked. + * \return Returns `true` iff the interrupt is unmasked, `false` otherwise + * + */ +bool status(uint8_t slot); +} // namespace IOAPIC diff --git a/kernel/arch/ioapic_registers.h b/kernel/arch/ioapic_registers.h new file mode 100644 index 0000000..eadb579 --- /dev/null +++ b/kernel/arch/ioapic_registers.h @@ -0,0 +1,228 @@ +/*! \file + * \brief Helper structures for interacting with the \ref IOAPIC "I/O APIC". + */ + +#pragma once +#include "../types.h" + +namespace IOAPIC { +typedef uint32_t Index; +typedef uint32_t Register; + +extern volatile Index *IOREGSEL_REG; +extern volatile Register *IOWIN_REG; + +/*! \brief I/O APIC Identification + * + * The IOAPICID register is register number 0x0. The I/O APIC's ID will be read + * from the system configuration tables (provided by the BIOS) during boot. The + * number can be queried by calling \ref APIC::getIOAPICID(). During + * initialization, this number must be written to the IOAPICID register. + * + * \see [IO-APIC manual](intel_ioapic.pdf#page=9), page 9 + */ +union Identification { + struct { + uint32_t : 24, ///< Reserved, do not modify + id : 4, ///< I/O APIC Identification + : 4; ///< Reserved, do not modify + }; + Register value; + explicit Identification(Register value) : value(value) {} +} __attribute__((packed)); +static_assert(sizeof(Identification) == 4, + "IOAPIC Identification has wrong size"); + +/*! \brief Delivery mode specifies the type of interrupt sent to the CPU. */ +enum DeliveryMode { + FIXED = 0, ///< "ordinary" interrupt; send to ALL cores listed in the + ///< destination bit mask + LOWEST_PRIORITY = 1, ///< "ordinary" interrupt; send to the lowest priority + ///< core from destination mask + SMI = 2, ///< System Management Interrupt; vector number required to be 0 + // Reserved + NMI = 4, ///< Non-Maskable Interrupt, vector number ignored, only edge + ///< triggered + INIT = 5, ///< Initialization interrupt (always treated as edge triggered) + // Reserved + EXTERN_INT = 7 ///< external interrupt (only edge triggered) +}; + +/*! \brief Way of interpreting the value written to the destination field. */ +enum DestinationMode { + PHYSICAL = 0, ///< Destination contains the physical destination APIC ID + LOGICAL = 1 ///< Destination contains a mask of logical APIC IDs +}; + +/*! \brief Interrupt polarity for the redirection-table entry */ +enum Polarity { + HIGH = 0, ///< active high + LOW = 1 ///< active low +}; + +/*! \brief Trigger mode */ +enum TriggerMode { + EDGE = 0, ///< edge triggered + LEVEL = 1 ///< level triggered +}; + +/*! \brief Interrupt state */ +enum DeliveryStatus { + IDLE = 0, ///< No activity for this interrupt + SEND_PENDING = + 1 ///< Interrupt will be sent as soon as the bus / LAPIC is ready +}; + +/*! \brief Interrupt masking */ +enum InterruptMask { + UNMASKED = 0, ///< Redirection-table entry is active (non-masked) + MASKED = 1 ///< Redirection-table entry is inactive (masked) +}; + +/*! \brief Entry in the redirection table. + * + * The redirection table begins with I/O APIC register `0x10` and ends at + * `0x3f`. + * + * Each entry has a size of 64 bit, equaling two I/O APIC registers. + * For instance, entry 0 is stored in registers `0x10` and `0x11`, in which the + * low-order 32 bit (equals \ref value_low) and high-order 32 bit (equals \ref + * value_high) need to be stored. + * + * The union defined below provides an overlay allowing convenient modification + * of individual bits, while the 32-bit values \ref value_low and \ref + * value_high can be used for writing to the I/O APIC registers. + * + * \note [Type punning](https://en.wikipedia.org/wiki/Type_punning#Use_of_union) + * is indeed undefined behavior in C++. However, *gcc* explicitly allows + * this construct as a [language extension](https://gcc.gnu.org/bugs/#nonbugs). + * Some compilers ([other than + * gcc](https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#Type%2Dpunning) + * might allow this feature only by disabling strict aliasing + * (`-fno-strict-aliasing`). In \StuBS we use this feature extensively due to + * the improved code readability. + * + * \see [IO-APIC manual](intel_ioapic.pdf#page=11), page 11-13 + */ +union RedirectionTableEntry { + // @cond ANONYMOUS_STRUCT + struct { + // @endcond + + /*! \brief Interrupt vector in the \ref IDT "Interrupt Descriptor Table + * (IDT)" will be activated when the corresponding external interrupt + * triggers. + */ + uint64_t vector : 8; + + /*! \brief The delivery mode denotes the way the interrupts will be + * delivered to the local CPU cores, respectively to their local APICs. + * + * For StuBS, we use \ref LOWEST_PRIORITY, as all CPU cores have the + * same priority and we want to distribute interrupts evenly among them. + * It, however, is not guaranteed that this method of load balancing + * will work on every system. + */ + DeliveryMode delivery_mode : 3; + + /*! \brief The destination mode defines how the value stored in \ref + * destination will be interpreted. + * + * For StuBS, we use \ref LOGICAL + */ + DestinationMode destination_mode : 1; + + /*! \brief Delivery status holds the current status of interrupt + * delivery. + * + * \note This field is read only; write accesses to this field will be + * ignored. + */ + DeliveryStatus delivery_status : 1; + + /*! \brief The polarity denotes when an interrupt should be issued. + * + * For StuBS, we usually use \ref HIGH (i.e., when the interrupt line + * is, logically, `1`). + */ + Polarity polarity : 1; + + /*! \brief The remote IRR bit indicates whether the local APIC(s) accept + * the level interrupt. + * + * Once the LAPIC sends an \ref LAPIC::endOfInterrupt "End Of Interrupt + * (EOI)", this bit is reset to `0`. + * + * \note This field is read only and is only meaningful for + * level-triggered interrupts. + */ + uint64_t remote_irr : 1; + + /*! \brief The trigger mode states whether the interrupt signaling is + * level or edge triggered. + * + * StuBS uses \ref EDGE for the Timer, the Keybaord and (optional) + * serial interface need \ref LEVEL + */ + TriggerMode trigger_mode : 1; + + /*! \brief Mask or unmask interrupts for a particular, external source. + * + * The interrupt mask denotes whether interrupts should be + * accepted/unmasked (value \ref UNMASKED) or ignored/masked (value \ref + * MASKED). + */ + InterruptMask interrupt_mask : 1; + + /*! \brief Reserved, do not modify. */ + uint64_t : 39; + + /*! \brief Interrupt destination. + * + * The meaning of destination depends on the destination mode: + * For the logical destination mode, destination holds a bit mask made + * up of the cores that are candidates for receiving the interrupt. In + * the single-core case, this value is `1`, in the multi-core case, the + * `n` low-order bits needs to be set (with `n` being the number of CPU + * cores, see \ref Core::count() ). Setting the `n` low-order bits marks + * all available cores as candidates for receiving interrupts and + * thereby balancing the number of interrupts between the cores. + * + * \note This form of load balancing depends on the hardware's behavior + * and may not work on all systems in the same fashion. Most notably, in + * QEMU all interrupts are sent to the BSP (core 0). + */ + uint64_t destination : 8; + + // @cond ANONYMOUS_STRUCT + } __attribute__((packed)); + // @endcond + + // @cond ANONYMOUS_STRUCT + struct { + // @endcond + + Register value_low; ///< Low-order 32 bits (for the register with the + ///< smaller index) + Register value_high; ///< High-order 32 bits (for the register with the + ///< higher index) + // @cond ANONYMOUS_STRUCT + } __attribute__((packed)); + // @endcond + + /*! \brief Constructor for an redirection-table entry + * + * Every entry in the redirection table represents an external source of + * interrupts and has a size of 64 bits. Due to the I/O APIC registers being + * only 32 bits wide, the constructor takes two 32 bit values. + * + * \param value_low First, low-order 32 bit value + * \param value_high Second, high-order 32 bit value + */ + RedirectionTableEntry(Register value_low, Register value_high) + : value_low(value_low), value_high(value_high) {} +}; + +static_assert(sizeof(RedirectionTableEntry) == 8, + "IOAPIC::RedirectionTableEntry has wrong size"); +} // namespace IOAPIC diff --git a/kernel/arch/ioport.h b/kernel/arch/ioport.h new file mode 100644 index 0000000..4042cd9 --- /dev/null +++ b/kernel/arch/ioport.h @@ -0,0 +1,63 @@ +/*! \file + * \brief \ref IOPort provides access to the x86 IO address space + */ + +#pragma once +#include "../types.h" + +/*! \brief Abstracts access to the I/O address space + * + * x86 PCs have a separated I/O address space that is accessible only via the + * machine instructions `in` and `out`. An IOPort object encapsulates the + * corresponding address in the I/O address space and can be used for byte or + * word-wise reading or writing. + */ + +class IOPort { + /*! \brief Address in I/O address space + * + */ + uint16_t address; + + public: + /*! \brief Constructor + * \param addr Address from the I/O address space + */ + explicit constexpr IOPort(uint16_t addr) : address(addr) {} + + /*! \brief Write one byte to the I/O port + * \param val The value to be written + */ + void outb(uint8_t val) const { + asm volatile("out %%al, %%dx\n\t" : : "a"(val), "d"(address) :); + } + + /*! \brief Write one word (2 bytes) to the I/O port + * \param val The value to be written + */ + void outw(uint16_t val) const { + asm volatile("out %%ax, %%dx\n\t" : : "a"(val), "d"(address) :); + } + + /*! \brief Read one byte from the I/O port + * \return Read byte + */ + uint8_t inb() const { + uint8_t out = 0; + + asm volatile("in %%dx, %%al\n\t" : "=a"(out) : "d"(address) :); + + return out; + } + + /*! \brief Read one word (2 bytes) from the I/O port + * \return Read word (2 bytes) + */ + uint16_t inw() const { + uint16_t out = 0; + + asm volatile("inw %%dx, %%ax\n\t" : "=a"(out) : "d"(address) :); + + return out; + } +}; diff --git a/kernel/arch/lapic.cc b/kernel/arch/lapic.cc new file mode 100644 index 0000000..8872f3e --- /dev/null +++ b/kernel/arch/lapic.cc @@ -0,0 +1,191 @@ +#include "lapic.h" + +#include "lapic_registers.h" + +namespace LAPIC { + +/*! \brief Base Address + * used with offset to access memory mapped registers + */ +volatile uintptr_t base_address = 0xfee00000; + +Register read(Index idx) { + return *reinterpret_cast(base_address + idx); +} +void write(Index idx, Register value) { + *reinterpret_cast(base_address + idx) = value; +} + +/*! \brief Local APIC ID (for Pentium 4 and newer) + * + * Is assigned automatically during boot and should not be changed. + * + * \see [ISDMv3, 10.4.6 Local APIC ID](intel_manual_vol3.pdf#page=371) + */ +union IdentificationRegister { + struct { + uint32_t : 24, ///< (reserved) + apic_id : 8; ///< APIC ID + }; + Register value; + + IdentificationRegister() : value(read(Index::IDENTIFICATION)) {} +} __attribute__((packed)); + +/*! \brief Local APIC Version + * + * \see [ISDMv3 10.4.8 Local APIC Version + * Register](intel_manual_vol3.pdf#page=373) + */ +union VersionRegister { + struct { + uint32_t version : 8, ///< 0x14 for P4 and Xeon, 0x15 for more recent + ///< hardware + : 8, ///< (reserved) + max_lvt_entry : 8, ///< Maximum number of local vector entries + suppress_eoi_broadcast : 1, ///< Support for suppressing EOI + ///< broadcasts + : 7; ///< (reserved) + }; + Register value; + + VersionRegister() : value(read(Index::VERSION)) {} +} __attribute__((packed)); + +/*! \brief Logical Destination Register + * \see [ISDMv3 10.6.2.2 Logical Destination + * Mode](intel_manual_vol3.pdf#page=385) + */ +union LogicalDestinationRegister { + struct { + uint32_t : 24, ///< (reserved) + lapic_id : 8; ///< Logical APIC ID + }; + Register value; + + LogicalDestinationRegister() : value(read(Index::LOGICAL_DESTINATION)) {} + ~LogicalDestinationRegister() { write(Index::LOGICAL_DESTINATION, value); } +} __attribute__((packed)); + +enum Model { CLUSTER = 0x0, FLAT = 0xf }; + +/*! \brief Destination Format Register + * + * \see [ISDMv3 10.6.2.2 Logical Destination + * Mode](intel_manual_vol3.pdf#page=385) + */ +union DestinationFormatRegister { + struct { + uint32_t : 28; ///< (reserved) + Model model : 4; ///< Model (Flat vs. Cluster) + }; + Register value; + DestinationFormatRegister() : value(read(Index::DESTINATION_FORMAT)) {} + ~DestinationFormatRegister() { write(Index::DESTINATION_FORMAT, value); } +} __attribute__((packed)); + +/*! \brief Task Priority Register + * + * \see [ISDMv3 10.8.3.1 Task and Processor + * Priorities](intel_manual_vol3.pdf#page=391) + */ +union TaskPriorityRegister { + struct { + uint32_t task_prio_sub : 4, ///< Task Priority Sub-Class + task_prio : 4, ///< Task Priority + : 24; ///< (reserved) + }; + Register value; + TaskPriorityRegister() : value(read(Index::TASK_PRIORITY)) {} + ~TaskPriorityRegister() { write(Index::TASK_PRIORITY, value); } +} __attribute__((packed)); + +/*! \brief APIC Software Status for Spurious Interrupt Vector */ +enum APICSoftware { + APIC_DISABLED = 0, + APIC_ENABLED = 1, +}; + +/*! \brief Focus Processor Checking for Spurious Interrupt Vector */ +enum FocusProcessorChecking { + CHECKING_ENABLED = 0, + CHECKING_DISABLED = 1, +}; + +/*! \brief Suppress End-Of-Interrupt-Broadcast for Spurious Interrupt Vector */ +enum SuppressEOIBroadcast { + BROADCAST = 0, + SUPPRESS_BROADCAST = 1, +}; + +/*! \brief Spurious Interrupt Vector Register + * + * \see [ISDMv3 10.9 Spurious Interrupt](intel_manual_vol3.pdf#page=394) + */ +union SpuriousInterruptVectorRegister { + struct { + uint32_t spurious_vector : 8; ///< Spurious Vector + APICSoftware apic_software : 1; ///< APIC Software Enable/Disable + FocusProcessorChecking + focus_processor_checking : 1; ///< Focus Processor Checking + uint32_t reserved_1 : 2; + SuppressEOIBroadcast eoi_broadcast_suppression : 1; + uint32_t reserved : 19; + }; + Register value; + + SpuriousInterruptVectorRegister() + : value(read(Index::SPURIOUS_INTERRUPT_VECTOR)) {} + ~SpuriousInterruptVectorRegister() { + write(Index::SPURIOUS_INTERRUPT_VECTOR, value); + } +} __attribute__((packed)); +static_assert(sizeof(SpuriousInterruptVectorRegister) == 4, + "LAPIC Spurious Interrupt Vector has wrong size"); + +uint8_t getID() { + IdentificationRegister ir; + return ir.apic_id; +} + +uint8_t getLogicalID() { + LogicalDestinationRegister ldr; + return ldr.lapic_id; +} + +uint8_t getVersion() { + VersionRegister vr; + return vr.version; +} + +void init(uint8_t logical_id) { + // reset logical destination ID + // can be set using setLogicalLAPICID() + LogicalDestinationRegister ldr; + ldr.lapic_id = logical_id; + + // set task priority to 0 -> accept all interrupts + TaskPriorityRegister tpr; + tpr.task_prio = 0; + tpr.task_prio_sub = 0; + + // set flat delivery mode + DestinationFormatRegister dfr; + dfr.model = Model::FLAT; + + // use 255 as spurious vector, enable APIC and disable focus processor + SpuriousInterruptVectorRegister sivr; + sivr.spurious_vector = 0xff; + sivr.apic_software = APICSoftware::APIC_ENABLED; + sivr.focus_processor_checking = FocusProcessorChecking::CHECKING_DISABLED; +} + +void endOfInterrupt() { + // dummy read + read(SPURIOUS_INTERRUPT_VECTOR); + + // signal end of interrupt + write(EOI, 0); +} + +} // namespace LAPIC diff --git a/kernel/arch/lapic.h b/kernel/arch/lapic.h new file mode 100644 index 0000000..21b2f57 --- /dev/null +++ b/kernel/arch/lapic.h @@ -0,0 +1,194 @@ +/*! \file + * \brief \ref LAPIC abstracts access to the Local \ref APIC + */ + +#pragma once +#include "../types.h" + +/*! \brief Abstracts the local APIC (which is integrated into every CPU core) + * \ingroup interrupts + * + * In modern (x86) PCs, every CPU core has its own Local APIC (LAPIC). The + * LAPIC is the link between the local CPU core and the I/O APIC (that takes + * care about external interrupt sources. Interrupt messages received by the + * LAPIC will be passed to the corresponding CPU core and trigger the interrupt + * handler on this core. + * + * \see [ISDMv3 10.4 Local APIC](intel_manual_vol3.pdf#page=366) + */ +namespace LAPIC { +/*! \brief Initialized the local APIC of the calling CPU core and sets the + * logical LAPIC ID in the LDR register + * \param logical_id APIC ID to be set + */ +void init(uint8_t logical_id); + +/*! \brief Signalize EOI (End of interrupt) + * + * Signals to the LAPIC that the handling of the current interrupt finished. + * This function must be called at the end of interrupt handling before ireting. + */ +void endOfInterrupt(); + +/*! \brief Get the ID of the current core's LAPIC + * \return LAPIC ID + */ +uint8_t getID(); + +/*! \brief Get the Logical ID of the current core's LAPIC + * \return Logical ID + */ +uint8_t getLogicalID(); + +/*! \brief Set the Logical ID of the current core's LAPIC + * \param id new Logical ID + */ +void setLogicalID(uint8_t id); + +/*! \brief Get version number of local APIC + * \return version number + */ +uint8_t getVersion(); + +/*! \brief Inter-Processor Interrupts + * + * For multi-core systems, the LAPIC enables sending messages (Inter-Processor + * Interrupts, IPIs) to other CPU cores and receiving those sent from other + * cores. + * + * \see [ISDMv3 10.6 Issuing Interprocessor + * Interrupts](intel_manual_vol3.pdf#page=380) + */ +namespace IPI { + +/*! \brief Check if the previously sent IPI has reached its destination. + * + * \return `true` if the previous IPI was accepted from its target processor, + * otherwise `false` + */ +bool isDelivered(); + +/*! \brief Send an Inter-Processor Interrupt (IPI) + * \param destination ID of the target processor (use APIC::getLAPICID(core) ) + * \param vector Interrupt vector number to be triggered + */ +void send(uint8_t destination, uint8_t vector); + +/*! \brief Send an Inter-Processor Interrupt (IPI) to a group of processors + * \param logical_destination Mask containing the logical APIC IDs of the target + * processors (use APIC::getLogicalLAPICID()) + * \param vector Interrupt vector number to be triggered + */ +void sendGroup(uint8_t logical_destination, uint8_t vector); + +/*! \brief Send an Inter-Processor Interrupt (IPI) to all processors (including + * self) + * \param vector Interrupt vector number to be triggered + */ +void sendAll(uint8_t vector); + +/*! \brief Send an Inter-Processor Interrupt (IPI) to all other processors (all + * but self) + * \param vector Interrupt vector number to be triggered + */ +void sendOthers(uint8_t vector); + +/*! \brief Send an INIT request IPI to all other processors + * + * \note Only required for startup + * + * \param assert if `true` send an INIT, + * on `false` send an INIT Level De-assert + */ +void sendInit(bool assert = true); + +/*! \brief Send an Startup IPI to all other processors + * + * \note Only required for startup + * + * \param vector Pointer to a startup routine + */ +void sendStartup(uint8_t vector); + +} // namespace IPI + +/*! \brief Local Timer (for each LAPIC / CPU) + * + * \see [ISDMv3 10.5.4 APIC Timer](intel_manual_vol3.pdf#page=378) + */ +namespace Timer { + +/*! \brief Determines the LAPIC timer's frequency. + * + * This function will calculate the number of LAPIC-timer ticks passing in the + * course of one millisecond. To do so, this function will rely on the PIT timer + * functionality and measure the tick delta between start and end of waiting for + * a predefined period. + * + * For measurement, the LAPIC-timer single-shot mode (without interrupts) is + * used; after the measurement, the timer is disabled again. + * + * \note The LAPIC-timer counts towards zero. + * + * \return Number of LAPIC-timer ticks per millisecond + * + */ +uint32_t measureTickRate(); // XXX: these should be "private" + +/*! \brief Configures the LAPIC timer hardware + * \param counter Initial counter value; decremented on every LAPIC timer tick + * \param divide Divider (power of 2, i.e., 1 2 4 8 16 32...) used as + * prescaler between bus frequency and LAPIC timer frequency: `LAPIC timer + * frequency = divide * bus frequency`. `divide` is a numerical parameter, the + * conversion to the corresponding bit mask is done internally by calling + * getClockDiv(). + * \param vector Interrupt vector number to be triggered on counter expiry + * \param periodic If set, the interrupt will be repeated periodically + * \param masked If set, interrupts on counter expiry are suppressed + * + */ +void set(uint32_t counter, uint8_t divide, uint8_t vector, bool periodic, + bool masked = false); // XXX: these should be "private" + +/*! \brief Prepares \ref LAPIC::Timer. + * + * Prepares the internal state of the \ref LAPIC::Timer + * such that regular interrupts are triggered approx. every `us` + * microseconds when \ref LAPIC::Timer::activate() is called. + * For this purpose, a suitable timer divisor is calculated + * based on the timer frequency determined with \ref + * LAPIC::Timer::measureTickRate(). This timer divisor has to be as small as + * possible, but large enough to prevent the 32bit counter from overflowing. + * + * \param us Desired interrupt interval in microseconds. + * \return Whether the interval could be set. + * + */ +bool setup(uint32_t us); // XXX: rename to "prepare", as it does not actually +// "set up" the timer? + +/*! \brief Retrieve the interrupt interval set during \ref LAPIC::Timer::setup() + * + * \return Interval in microseconds + * + */ +uint32_t interval(); + +/*! \brief Activate the timer on this core. + * + * Starts the core local timer with the interval previously calculated in + * \ref LAPIC::Timer::setup(). To get timer interrupts on all cores, this method + * must be called once per core (however, it is sufficient to call \ref + * LAPIC::Timer::setup() only once since the APIC-Bus frequency is the same on + * each core). + * + */ +void activate(); + +/*! \brief Set the LAPIC-timer interrupt mask + * \param masked If set, interrupts are suppressed on counter expiry. + * + */ +void setMasked(bool masked); +} // namespace Timer +} // namespace LAPIC diff --git a/kernel/arch/lapic_ipi.cc b/kernel/arch/lapic_ipi.cc new file mode 100644 index 0000000..dbec009 --- /dev/null +++ b/kernel/arch/lapic_ipi.cc @@ -0,0 +1,245 @@ +#include "lapic_registers.h" + +namespace LAPIC { +namespace IPI { + +/*! \brief Delivery mode specifies the type of interrupt sent to the CPU. */ +enum class DeliveryMode : uint8_t { + FIXED = 0, ///< "ordinary" interrupt; send to ALL cores listed in the + ///< destination bit mask + LOWEST_PRIORITY = 1, ///< "ordinary" interrupt; send to the lowest priority + ///< core from destination mask + SMI = 2, ///< System Management Interrupt; vector number required to be 0 + // Reserved + NMI = 4, ///< Non-Maskable Interrupt, vector number ignored, only edge + ///< triggered + INIT = 5, ///< Initialization interrupt (always treated as edge triggered) + INIT_LEVEL_DEASSERT = 5, ///< Synchronization interrupt + STARTUP = 6, ///< Dedicated Startup-Interrupt (SIPI) + // Reserved +}; + +/*! \brief Way of interpreting the value written to the destination field. */ +enum class DestinationMode : uint8_t { + PHYSICAL = 0, ///< Destination contains the physical destination APIC ID + LOGICAL = 1 ///< Destination contains a mask of logical APIC IDs +}; + +/*! \brief Interrupt state */ +enum class DeliveryStatus : uint8_t { + IDLE = 0, ///< No activity for this interrupt + SEND_PENDING = + 1 ///< Interrupt will be sent as soon as the bus / LAPIC is ready +}; + +/*! \brief Interrupt level */ +enum class Level : uint8_t { + DEASSERT = 0, ///< Must be zero when DeliveryMode::INIT_LEVEL_DEASSERT + ASSERT = 1 ///< Must be one for all other delivery modes +}; + +/*! \brief Trigger mode for DeliveryMode::INIT_LEVEL_DEASSERT */ +enum class TriggerMode : uint8_t { + EDGE_TRIGGERED = 0, ///< edge triggered + LEVEL_TRIGGERED = 1 ///< level triggered +}; + +/*! \brief Shorthand for commonly used destinations */ +enum class DestinationShorthand : uint8_t { + NO_SHORTHAND = 0, ///< Use destination field instead of shorthand + SELF = 1, ///< Send IPI to self + ALL_INCLUDING_SELF = 2, ///< Send IPI to all including self + ALL_EXCLUDING_SELF = 3 ///< Send IPI to all except self +}; + +/*! \brief Interrupt mask */ +enum class InterruptMask : uint8_t { + UNMASKED = 0, ///< Interrupt entry is active (non-masked) + MASKED = 1 ///< Interrupt entry is deactivated (masked) +}; + +/*! \brief Interrupt Command + * + * \see [ISDMv3 10.6.1 Interrupt Command Register + * (ICR)](intel_manual_vol3.pdf#page=381) + */ +union InterruptCommand { + struct { + /*! \brief Interrupt vector in the \ref IDT "Interrupt Descriptor Table + * (IDT)" will be activated when the corresponding external interrupt + * triggers. + *//*! \brief Interrupt vector in the \ref IDT "Interrupt Descriptor Table (IDT)" will be +* activated when the corresponding external interrupt triggers. +*/ + uint64_t vector : 8; + + /*! \brief The delivery mode denotes the way the interrupts will be + * delivered to the local CPU cores, respectively to their local APICs. + * + * For StuBS, we use `DeliveryMode::LowestPriority`, as all CPU cores + * have the same priority and we want to distribute interrupts evenly + * among them. It, however, is not guaranteed that this method of load + * balancing will work on every system. + */ + enum DeliveryMode delivery_mode : 3; + + /*! \brief The destination mode defines how the value stored in + * `destination` will be interpreted. + * + * For StuBS, we use `DestinationMode::Logical`. + */ + enum DestinationMode destination_mode : 1; + + /*! \brief Delivery status holds the current status of interrupt + * delivery. + * + * \note This field is read only; write accesses to this field will be + * ignored. + */ + enum DeliveryStatus delivery_status : 1; + + uint64_t : 1; ///< reserved + + /*! \brief The polarity denotes when an interrupt should be issued. + * + * For StuBS, we use `Polarity::High` (i.e., when the interrupt line + * is, logically, 1). + */ + enum Level level : 1; + + /*! \brief The trigger mode states whether the interrupt signaling is + * level or edge triggered. + * + * StuBS uses `TriggerMode::Edge` for Keyboard and Timer, the + * (optional) serial interface, however, needs `TriggerMode::Level`. + */ + enum TriggerMode trigger_mode : 1; + + uint64_t : 2; ///< reserved + + enum DestinationShorthand destination_shorthand : 2; + + uint64_t : 36; ///< Reserved, do not modify + + /*! \brief Interrupt destination. + * + * The meaning of destination depends on the destination mode: + * For the logical destination mode, destination holds a bit mask made + * up of the cores that are candidates for receiving the interrupt. In + * the single-core case, this value is `1`, in the multi-core case, the + * `n` low-order bits needs to be set (with `n` being the number of CPU + * cores, see \ref Core::count() ). Setting the `n` low-order bits marks + * all available cores as candidates for receiving interrupts and + * thereby balancing the number of interrupts between the cores. + * + * \note This form of load balancing depends on the hardware's behavior + * and may not work on all systems in the same fashion. Most notably, in + * QEMU all interrupts are sent to the BSP (core 0). + */ + uint64_t destination : 8; + } __attribute__((packed)); + + /*! \brief I/O redirection-table entry + * + * Every entry in the redirection table represents an external source of + * interrupts and has a size of 64 bits. Due to the I/O APIC registers being + * only 32 bits wide, the 64-bit value is split in two 32 bit values. + */ + struct { + Register value_low; ///< First, low-order register + Register value_high; ///< Second, high-order register + } __attribute__((packed)); + + /*! \brief Default constructor */ + InterruptCommand() = default; + + explicit InterruptCommand( + uint8_t destination, uint8_t vector = 0, + DestinationMode destination_mode = DestinationMode::PHYSICAL, + DeliveryMode delivery_mode = DeliveryMode::FIXED, + TriggerMode trigger_mode = TriggerMode::EDGE_TRIGGERED, + Level level = Level::ASSERT) { + readRegister(); + this->vector = vector; + this->delivery_mode = delivery_mode; + this->destination_mode = destination_mode; + this->level = level; + this->trigger_mode = trigger_mode; + this->destination_shorthand = DestinationShorthand::NO_SHORTHAND; + this->destination = destination; + } + + InterruptCommand(DestinationShorthand destination_shorthand, uint8_t vector, + DeliveryMode delivery_mode = DeliveryMode::FIXED, + TriggerMode trigger_mode = TriggerMode::EDGE_TRIGGERED, + Level level = Level::ASSERT) { + readRegister(); + this->vector = vector; + this->delivery_mode = delivery_mode; + this->level = level; + this->trigger_mode = trigger_mode; + this->destination_shorthand = destination_shorthand; + this->destination = destination; + } + + void send() const { + write(INTERRUPT_COMMAND_REGISTER_HIGH, value_high); + write(INTERRUPT_COMMAND_REGISTER_LOW, value_low); + } + + bool isSendPending() { + value_low = read(INTERRUPT_COMMAND_REGISTER_LOW); + return delivery_status == DeliveryStatus::SEND_PENDING; + } + + private: + void readRegister() { + while (isSendPending()) { + } + value_high = read(INTERRUPT_COMMAND_REGISTER_HIGH); + } +}; +static_assert(sizeof(InterruptCommand) == 8, + "LAPIC Interrupt Command has wrong size"); + +bool isDelivered() { + InterruptCommand ic; + return !ic.isSendPending(); +} + +void send(uint8_t destination, uint8_t vector) { + InterruptCommand ic(destination, vector); + ic.send(); +} + +void sendGroup(uint8_t logical_destination, uint8_t vector) { + InterruptCommand ic(logical_destination, vector, DestinationMode::LOGICAL); + ic.send(); +} + +void sendAll(uint8_t vector) { + InterruptCommand ic(DestinationShorthand::ALL_INCLUDING_SELF, vector); + ic.send(); +} + +void sendOthers(uint8_t vector) { + InterruptCommand ic(DestinationShorthand::ALL_EXCLUDING_SELF, vector); + ic.send(); +} + +void sendInit(bool assert) { + LAPIC::IPI::InterruptCommand ic( + DestinationShorthand::ALL_EXCLUDING_SELF, 0, DeliveryMode::INIT, + assert ? TriggerMode::EDGE_TRIGGERED : TriggerMode::LEVEL_TRIGGERED, + assert ? Level::ASSERT : Level::DEASSERT); + ic.send(); +} + +void sendStartup(uint8_t vector) { + InterruptCommand ic(DestinationShorthand::ALL_EXCLUDING_SELF, vector, + DeliveryMode::STARTUP); + ic.send(); +} + +} // namespace IPI +} // namespace LAPIC diff --git a/kernel/arch/lapic_registers.h b/kernel/arch/lapic_registers.h new file mode 100644 index 0000000..58b37d0 --- /dev/null +++ b/kernel/arch/lapic_registers.h @@ -0,0 +1,61 @@ +/*! \file + * \brief Structures and macros for accessing \ref LAPIC "the local APIC". + */ + +#pragma once +#include "../types.h" + +namespace LAPIC { +// Memory Mapped Base Address +extern volatile uintptr_t base_address; + +typedef uint32_t Register; + +/*! \brief Register Offset Index + * + * \see [ISDMv3 10.4.1 The Local APIC Block + * Diagram](intel_manual_vol3.pdf#page=368) + */ +enum Index : uint16_t { + /// Local APIC ID Register, RO (sometimes R/W). Do not change! + IDENTIFICATION = 0x020, + /// Local APIC Version Register, RO + VERSION = 0x030, + /// Task Priority Register, R/W + TASK_PRIORITY = 0x080, + /// EOI Register, WO + EOI = 0x0b0, + /// Logical Destination Register, R/W + LOGICAL_DESTINATION = 0x0d0, + /// Destination Format Register, bits 0-27 RO, bits 28-31 R/W + DESTINATION_FORMAT = 0x0e0, + /// Spurious Interrupt Vector Register, bits 0-8 R/W, bits 9-1 R/W + SPURIOUS_INTERRUPT_VECTOR = 0x0f0, + /// Interrupt Command Register 1, R/W + INTERRUPT_COMMAND_REGISTER_LOW = 0x300, + /// Interrupt Command Register 2, R/W + INTERRUPT_COMMAND_REGISTER_HIGH = 0x310, + /// LAPIC timer control register, R/W + TIMER_CONTROL = 0x320, + /// LAPIC timer initial counter register, R/W + TIMER_INITIAL_COUNTER = 0x380, + /// LAPIC timer current counter register, RO + TIMER_CURRENT_COUNTER = 0x390, + /// LAPIC timer divide configuration register, RW + TIMER_DIVIDE_CONFIGURATION = 0x3e0 +}; + +/*! \brief Get value from APIC register + * + * \param idx Register Offset Index + * \return current value of register + */ +Register read(Index idx); + +/*! \brief Write value to APIC register + * + * \param idx Register Offset Index + * \param value value to be written into register + */ +void write(Index idx, Register value); +} // namespace LAPIC diff --git a/kernel/arch/lapic_timer.cc b/kernel/arch/lapic_timer.cc new file mode 100644 index 0000000..286b1ac --- /dev/null +++ b/kernel/arch/lapic_timer.cc @@ -0,0 +1,177 @@ +#include "../debug/assert.h" +#include "core_interrupt.h" +#include "lapic.h" +#include "lapic_registers.h" +#include "pit.h" + +namespace LAPIC { +namespace Timer { + +/*! \brief Timer Delivery Status */ +enum class DeliveryStatus : uint8_t { IDLE = 0, SEND_PENDING = 1 }; + +/*! \brief Timer Mode */ +enum class TimerMode : uint8_t { + ONE_SHOT = 0, + PERIODIC = 1, + DEADLINE = 2 + // reserved +}; + +/*! \brief Timer Mask */ +enum class Mask : uint8_t { NOT_MASKED = 0, MASKED = 1 }; + +static const Register INVALID_DIV = 0xff; + +/*! \brief LAPIC-Timer Control Register + * + * \see [ISDMv3 10.5.1 Local Vector Table](intel_manual_vol3.pdf#page=375) + */ +union ControlRegister { + struct { + uint32_t vector : 8; ///< Vector + uint32_t : 4; + DeliveryStatus delivery_status : 1; ///< Delivery Status (readonly) + uint32_t : 3; + Mask masked : 1; ///< Interrupt Mask (if set, interrupt will not + ///< trigger) + TimerMode timer_mode : 2; ///< Timer Mode + uint32_t : 13; + }; + Register value; +} __attribute__((packed)); + +/*! \brief LAPIC timer divider table + * + * \see [ISDMv3 10.5.4 APIC Timer](intel_manual_vol3.pdf#page=378) + */ +static const Register div_masks[] = { + 0xb, ///< divides by 1 + 0x0, ///< divides by 2 + 0x1, ///< divides by 4 + 0x2, ///< divides by 8 + 0x3, ///< divides by 16 + 0x8, ///< divides by 32 + 0x9, ///< divides by 64 + 0xa ///< divides by 128 +}; + +/*! \brief Calculate the bit mask for the LAPIC-timer divider. + * \param div Divider, must be power of two: 1, 2, 4, 8, 16, 32, 64, 128 + * \return Bit mask for LAPIC::setTimer() or `0xff` if `div` is invalid. + */ +Register getClockDiv(uint8_t div) { + // div is zero or not a power of two? + if (div == 0 || (div & (div - 1)) != 0) { + return INVALID_DIV; + } + + int trail = __builtin_ctz(div); // count trailing 0-bits + if (trail > 7) { + return INVALID_DIV; + } + + return div_masks[trail]; +} + +uint32_t measureTickRate(void) { + uint32_t ticks = 0; // ticks per millisecond + // Calculation (Assignment 5) + // Steps taken for precise measurement of LAPIC-timer ticks per ms: + // 1. Disable Interrupts to ensure measurement is not disturbed + // 2. Configure a timeout of 50 ms (nearly PIT's maximum possible delay) + // Using a "large" value decreases the overhead induced by measurement + // and thereby increases the accuracy. + // 3. Now measure the number of passed LAPIC-timer ticks while waiting for + // the PIT + // Note that configuring the PIT takes quite some time and therefore + // should be done prior to starting LAPIC-timer measurement. + // 4. Restore previous state (disable PIT, LAPIC timer, restore interrupts) + // 5. Derive the ticks per millisecond (take care, the counter is counting + // towards zero) + + // Start LAPIC counter, single shot, no interrupts + set(UINT32_MAX, 1, 0, false, true); + bool status = Core::Interrupt::disable(); + + const uint32_t ms = 50; + PIT::set(ms * 1000); + + Register start = read(TIMER_CURRENT_COUNTER); + PIT::waitForTimeout(); + Register end = read(TIMER_CURRENT_COUNTER); + + set(0, 1, 0, false, true); + PIT::disable(); + Core::Interrupt::restore(status); + + ticks = (start - end) / ms; + return ticks; +} + +void set(uint32_t counter, uint8_t divide, uint8_t vector, bool periodic, + bool masked) { + // stop timer by setting counter to 0 + write(TIMER_INITIAL_COUNTER, 0); + + // write control register + ControlRegister tcr; + tcr.value = read(TIMER_CONTROL); + tcr.vector = vector; + tcr.timer_mode = periodic ? TimerMode::PERIODIC : TimerMode::ONE_SHOT; + tcr.masked = masked ? Mask::MASKED : Mask::NOT_MASKED; + write(TIMER_CONTROL, tcr.value); + + // set divider + Register clock_div = getClockDiv(divide); + assert(clock_div != INVALID_DIV); + write(TIMER_DIVIDE_CONFIGURATION, clock_div); + + // start timer + write(TIMER_INITIAL_COUNTER, static_cast(counter)); +} + +static uint32_t interv; +static uint32_t nticks; +static uint32_t div; + +bool setup(uint32_t us) { + if (us == 0) { + return false; + } + + uint64_t ticks_ms = measureTickRate(); + uint64_t tmp_ticks = (ticks_ms * us) / 1000; + uint32_t tmp32_ticks = static_cast(tmp_ticks); + + // Calculate LAPIC timer divider + for (int i = 1; i <= 128; i *= 2) { + if (tmp_ticks == static_cast(tmp32_ticks)) { + nticks = tmp32_ticks; + div = i; + interv = us; + return true; + } + tmp_ticks = tmp_ticks >> 1; + tmp32_ticks = static_cast(tmp_ticks); + } + + return false; +} + +uint32_t interval() { return interv; } + +void activate() { + set(nticks, div, static_cast(Core::Interrupt::Vector::TIMER), + true); +} + +void setMasked(bool masked) { + ControlRegister tcr; + tcr.value = read(TIMER_CONTROL); + tcr.masked = masked ? Mask::MASKED : Mask::NOT_MASKED; + write(TIMER_CONTROL, tcr.value); +} + +} // namespace Timer +} // namespace LAPIC diff --git a/kernel/arch/pic.cc b/kernel/arch/pic.cc new file mode 100644 index 0000000..8a11ae0 --- /dev/null +++ b/kernel/arch/pic.cc @@ -0,0 +1,65 @@ +#include "pic.h" + +#include "ioport.h" + +namespace PIC { + +void initialize() { + // Access primary & secondary PIC via two ports each + IOPort primary_port_a(0x20); + IOPort primary_port_b(0x21); + IOPort secondary_port_a(0xa0); + IOPort secondary_port_b(0xa1); + + // Initialization Command Word 1 (ICW1) + // Basic PIC configuration, starting initialization + enum InitializationCommandWord1 { + ICW4_NEEDED = 1 << 0, // use Initialization Command Word 4 + SINGLE_MODE = 1 << 1, // Single or multiple (cascade mode) 8259A + ADDRESS_INTERVAL_HALF = + 1 + << 2, // 4 or 8 bit interval between the interrupt vector locations + LEVEL_TRIGGERED = 1 << 3, // Level or edge triggered + ALWAYS_1 = 1 << 4, + }; + const uint8_t icw1 = InitializationCommandWord1::ICW4_NEEDED | + InitializationCommandWord1::ALWAYS_1; + // ICW1 in port A (each) + primary_port_a.outb(icw1); + secondary_port_a.outb(icw1); + + // Initialization Command Word 2 (ICW2): + // Configure interrupt vector base offset in port B + primary_port_b.outb(0x20); // Primary: IRQ Offset 32 + secondary_port_b.outb(0x28); // Secondary: IRQ Offset 40 + + // Initialization Command Word 3 (ICW3): + // Configure pin on primary PIC connected to secondary PIC + const uint8_t pin = 2; // Secondary connected on primary pin 2 + primary_port_b.outb(1 << pin); // Pin as bit mask for primary + secondary_port_b.outb(pin); // Pin as value (ID) for secondary + + // Initialization Command Word 4 (ICW4) + // Basic PIC configuration, starting initialization + enum InitializationCommandWord4 { + MODE_8086 = 1 << 0, // 8086/8088 or 8085 mode + AUTO_EOI = 1 << 1, // Single or multiple (cascade mode) 8259A + BUFFER_PRIMARY = 1 << 2, // Primary or secondary buffering + BUFFERED_MODE = 1 << 3, // Enable or disable buffering (for primary or + // secondary above) + SPECIAL_FULLY_NESTED = 1 << 4 // Special or non special fully nested + }; + const uint8_t icw4 = InitializationCommandWord4::MODE_8086 | + InitializationCommandWord4::AUTO_EOI; + // ICW3 in port B (each) + primary_port_b.outb(icw4); + secondary_port_b.outb(icw4); + + // Operation Control Word 1 (OCW1): + // Disable (mask) all hardware interrupts on both legacy PICs (we'll use + // APIC) + secondary_port_b.outb(0xff); + primary_port_b.outb(0xff); +} + +} // namespace PIC diff --git a/kernel/arch/pic.h b/kernel/arch/pic.h new file mode 100644 index 0000000..9baf514 --- /dev/null +++ b/kernel/arch/pic.h @@ -0,0 +1,18 @@ +/*! \file + * \brief Handle (disable) the old Programmable Interrupt Controller (PIC) + */ + +#pragma once +#include "../types.h" + +/*! \brief The Programmable Interrupt Controller (PIC aka 8259A) + */ +namespace PIC { + +/*! \brief Initialize the PICs (Programmable Interrupt Controller, 8259A), + * such that all 15 hardware interrupts are stored sequentially in the \ref IDT + * and the hardware interrupts are disabled (in favor of \ref APIC). + */ +void initialize(); + +} // namespace PIC diff --git a/kernel/arch/pit.cc b/kernel/arch/pit.cc new file mode 100644 index 0000000..b5152da --- /dev/null +++ b/kernel/arch/pit.cc @@ -0,0 +1,226 @@ +#include "pit.h" + +#include "core.h" +#include "ioport.h" + +namespace PIT { + +// we only use PIT channel 2 +const uint8_t CHANNEL = 2; +static IOPort data(0x40 + CHANNEL); + +/*! \brief Access mode + */ +enum AccessMode { + LATCH_COUNT_VALUE = 0, + LOW_BYTE_ONLY = 1, + HIGH_BYTE_ONLY = 2, + LOW_AND_HIGH_BYTE = 3 +}; + +/*! \brief Operating Mode + * + * \warning Channel 2 is not able to send interrupts, however, the status bit + * will be set + */ +enum OperatingMode { + INTERRUPT_ON_TERMINAL_COUNT = 0, + PROGRAMMABLE_ONE_SHOT = 1, + RATE_GENERATOR = 2, + SQUARE_WAVE_GENERATOR = 3, ///< useful for the PC speaker + SOFTWARE_TRIGGERED_STROBE = 4, + HARDWARE_TRIGGERED_STROBE = 5 +}; + +/*! \brief data format + */ +enum Format { + BINARY = 0, + BCD = 1 ///< Binary Coded Decimals +}; + +// Mode register (only writable) +static IOPort mode_register(0x43); +union Mode { + struct { + Format format : 1; + OperatingMode operating : 3; + AccessMode access : 2; + uint8_t channel : 2; + }; + uint8_t value; + + /*! \brief Constructor for mode, takes the numeric value */ + explicit Mode(uint8_t value) : value(value) {} + + /*! \brief Constructor for counting mode + * \param access Access mode to the 16-bit counter value + * \param operating Operating mode for the counter + * \param format Number format for the 16-bit counter values (binary or + * BCD) + */ + Mode(AccessMode access, OperatingMode operating, Format format) + : format(format), + operating(operating), + access(access), + channel(PIT::CHANNEL) {} + + /*! \brief (Default) constructor for reading the counter value + */ + Mode() : value(0) { this->channel = PIT::CHANNEL; } + + /*! \brief Write the value to the mode register + */ + void write() const { mode_register.outb(value); } +}; + +// The NMI Status and Control Register contains details about PIT counter 2 +static IOPort controlRegister(0x61); +union Control { + /*! \brief I/O-port bitmap for the NMI Status and Control Register + * \note Over time, the meaning of the bits stored at I/O port 0x61 + * changed; don't get the structure confused with old documentation on the + * IBM PC XT platform. + * \see [Intel® I/O Controller Hub 7 (ICH7) + * Family](i-o-controller-hub-7-datasheet.pdf#page=415), page 415 + */ + struct { + //! If enabled, the interrupt state will be visible at + //! status_timer_counter2 + uint8_t enable_timer_counter2 : 1; + uint8_t enable_speaker_data : 1; ///< If set, speaker output is equal + ///< to status_timer_counter2 + uint8_t enable_pci_serr : 1; ///< not important, do not modify + uint8_t enable_nmi_iochk : 1; ///< not important, do not modify + const uint8_t + refresh_cycle_toggle : 1; ///< not important, must be 0 on write + const uint8_t + status_timer_counter2 : 1; ///< will be set on timer expiration; + ///< must be 0 on write + const uint8_t + status_iochk_nmi_source : 1; ///< not important, must be 0 on write + const uint8_t + status_serr_nmi_source : 1; ///< not important, must be 0 on write + }; + uint8_t value; + + /*! \brief Constructor + * \param value Numeric value for the control register + */ + explicit Control(uint8_t value) : value(value) {} + + /*! \brief Default constructor + * Automatically reads the current contents from the control register. + */ + Control() : value(controlRegister.inb()) {} + + /*! \brief Write the current state to the control register. + */ + void write() const { controlRegister.outb(value); } +}; + +// The base frequency is, due to historic reasons, 1.193182 MHz. +const uint64_t BASE_FREQUENCY = 1193182ULL; + +bool set(uint16_t us) { + // Counter ticks for us + uint64_t counter = BASE_FREQUENCY * us / 1000000ULL; + + // As the hardware counter has a size of 16 bit, we want to check whether + // the calculated counter value is too large ( > 54.9ms ) + if (counter > 0xffff) { + return false; + } + + // Interrupt state should be readable in status register, but PC speaker + // should remain off + Control c; + c.enable_speaker_data = 0; + c.enable_timer_counter2 = 1; + c.write(); + + // Channel 2, 16-bit divisor, with mode 0 (interrupt) in binary format + Mode m(AccessMode::LOW_AND_HIGH_BYTE, + OperatingMode::INTERRUPT_ON_TERMINAL_COUNT, Format::BINARY); + m.write(); + + // Set the counter's start value + data.outb(counter & 0xff); // low + data.outb((counter >> 8) & 0xff); // high + + return true; +} + +uint16_t get(void) { + // Set mode to reading + Mode m; + m.write(); + + // Read low and high + uint16_t value = data.inb(); + value |= data.inb() << 8; + + return value; +} + +bool isActive(void) { + Control c; // reads the current value from the control register + return c.enable_timer_counter2 == 1 && c.status_timer_counter2 == 0; +} + +bool waitForTimeout(void) { + while (true) { + Control c; // reads the current value from the control register + if (c.enable_timer_counter2 == 0) { + return false; + } else if (c.status_timer_counter2 == 1) { + return true; + } else { + Core::pause(); + } + } +} + +bool delay(uint16_t us) { return set(us) && waitForTimeout(); } + +void pcspeaker(uint32_t freq) { + Control c; + if (freq == 0) { + disable(); + } else { + // calculate frequency divider + uint64_t div = BASE_FREQUENCY / freq; + if (div > 0xffff) { + div = 0xffff; + } + + // check if already configured + if (c.enable_speaker_data == 0) { + // if not, set mode + Mode m(AccessMode::LOW_AND_HIGH_BYTE, + OperatingMode::SQUARE_WAVE_GENERATOR, Format::BINARY); + m.write(); + } + + // write frequency divider + data.outb(div & 0xff); + data.outb((div >> 8) & 0xff); + + // already configured? (second part to prevent playing a wrong sound) + if (c.enable_speaker_data == 0) { + // activate PC speaker + c.enable_speaker_data = 1; + c.enable_timer_counter2 = 1; + c.write(); + } + } +} + +void disable(void) { + Control c; + c.enable_speaker_data = 0; + c.enable_timer_counter2 = 0; + c.write(); +} + +} // namespace PIT diff --git a/kernel/arch/pit.h b/kernel/arch/pit.h new file mode 100644 index 0000000..0f22f35 --- /dev/null +++ b/kernel/arch/pit.h @@ -0,0 +1,80 @@ +/*! \file + * \brief The old/historical \ref PIT "Programmable Interval Timer (PIT)" + */ + +#pragma once +#include "../types.h" + +/*! \brief Abstraction of the historical Programmable Interval Timer (PIT). + * + * Historically, PCs had a Timer component of type 8253 or 8254, modern systems + * come with a compatible chip. Each of these chips provides three 16-bit wide + * counters ("channel"), each running at a frequency of 1.19318 MHz. The timer's + * counting speed is thereby independent from the CPU frequency. + * + * Traditionally, the first counter (channel 0) was used for triggering + * interrupts, the second one (channel 1) controlled the memory refresh, and the + * third counter (channel 2) was assigned to the PC speaker. + * + * As the PIT's frequency is fixed to a constant value of 1.19318 MHz, the PIT + * can be used for calibration. For this purpose, we use channel 2 only. + * + * \note Interrupts should be disabled while configuring the timer. + */ +namespace PIT { + +/*! \brief Start timer + * + * Sets the channel 2 timer to the provided value and starts counting. + * + * \note The maximum waiting time is approx. 54,900 us (16 bit / 1.193 MHz). + * \param us Waiting time in us + * \return `true` if the counter is running; `false` if the waiting time + * exceeds the limits. + */ +bool set(uint16_t us); + +/*! \brief Reads the current timer value + * \return Current timer value + */ +uint16_t get(void); + +/*! \brief Check if the timer is running + * \return `true` if running, `false` otherwise + */ +bool isActive(void); + +/*! \brief (Active) waiting for timeout + * \return `true` when timeout was successfully hit, `false` if the timer was + * not active prior to calling. + */ +bool waitForTimeout(void); + +/*! \brief Set the timer and wait for timeout + * \note The maximum waiting time is approx. 54,900 us (16 bit / 1.193 MHz). + * \param us Waiting time in us + * \return `true` when waiting successfully terminated; `false` on error (e.g., + * waiting time exceeds its limits) + */ +bool delay(uint16_t us); + +/*! \brief Play a given frequency on the PC speaker. + * + * As the PC speaker is connected to PIT channel 2, the PIT can be used to play + * an acoustic signal. Playing sounds occupies the PIT, so it cannot be used for + * other purposes while playback. + * + * \note Not every PC has an activated PC speaker + * \note Qemu & KVM have to be launched with `-soundhw pcspk`. + * If you still cannot hear anything, try to set `QEMU_AUDIO_DRV` to + * `alsa` (by launching \StuBS with `QEMU_AUDIO_DRV=alsa make kvm`) + * \param freq Frequency (in Hz) of the sound to be played, or 0 to deactivate + * playback. + */ +void pcspeaker(uint32_t freq); + +/*! \brief Deactivate the timer + */ +void disable(void); + +} // namespace PIT diff --git a/kernel/arch/serial.cc b/kernel/arch/serial.cc new file mode 100644 index 0000000..b7e29e1 --- /dev/null +++ b/kernel/arch/serial.cc @@ -0,0 +1,55 @@ +#include "serial.h" + +#include "ioport.h" + +Serial::Serial(ComPort port, BaudRate baud_rate, DataBits data_bits, + StopBits stop_bits, Parity parity) + : port(port) { + // initialize FIFO mode, no irqs for sending, irq if first byte was received + + // line control, select r/w of divisor latch register + writeReg(RegisterIndex::LINE_CONTROL, + static_cast(RegisterMask::DIVISOR_LATCH_ACCESS_BIT)); + + // config divisor + uint16_t divisor = static_cast(baud_rate); + // write low byte of divisor latch + writeReg(RegisterIndex::DIVISOR_LOW, divisor & 0xff); + // write high byte + writeReg(RegisterIndex::DIVISOR_HIGH, (divisor >> 8) & 0xff); + + // deselect r/w of divisor latch register + // configure line control + writeReg(RegisterIndex::LINE_CONTROL, static_cast(data_bits) | + static_cast(stop_bits) | + static_cast(parity)); + + // FIFO: Enable & clear buffers + writeReg(RegisterIndex::FIFO_CONTROL, + static_cast(RegisterMask::ENABLE_FIFO) | + static_cast(RegisterMask::CLEAR_RECEIVE_FIFO) | + static_cast(RegisterMask::CLEAR_TRANSMIT_FIFO)); + + // Modem Control: OUT2 (0000 1000) must be set for interrupt + writeReg(RegisterIndex::MODEM_CONTROL, + static_cast(RegisterMask::OUT_2)); +} + +void Serial::writeReg(RegisterIndex reg, uint8_t out) { + IOPort p(static_cast(port) + static_cast(reg)); + p.outb(out); +} + +uint8_t Serial::readReg(RegisterIndex reg) { + IOPort p(static_cast(port) + static_cast(reg)); + return p.inb(); +} + +int Serial::write(uint8_t out) { + while ((readReg(RegisterIndex::LINE_STATUS) & + static_cast(RegisterMask::TRANSMITTER_EMPTY)) == 0) { + } + + writeReg(RegisterIndex::TRANSMIT_BUFFER, out); + return out; +} diff --git a/kernel/arch/serial.h b/kernel/arch/serial.h new file mode 100644 index 0000000..5585369 --- /dev/null +++ b/kernel/arch/serial.h @@ -0,0 +1,196 @@ +/*! \file + * \brief Communication via the \ref Serial interface (RS-232) + */ + +#pragma once +#include "../types.h" + +/*! \brief Serial interface. + * \ingroup io + * + * This class provides a serial interface (COM1 - COM4) for communication with + * the outside world. + * + * The first IBM PC used the external chip [8250 + * UART](https://de.wikipedia.org/wiki/NSC_8250), whereas, in today's systems, + * this functionality is commonly integrated into the motherboard chipset, but + * remained compatible. + * + * \see [PC8250A Data Sheet](uart-8250a.pdf#page=11) (Registers on page 11) + * \see [PC16550D Data Sheet](uart-16550d.pdf#page=16) (Successor, for optional + * FIFO buffer, page 16) + */ + +class Serial { + public: + /*! \brief COM-Port + * + * The serial interface and its hardware addresses. Modern desktop PCs + * have, at most, a single, physical COM-port (`COM1`) + */ + enum class ComPort : uint16_t { + COM1 = 0x3f8, + COM2 = 0x2f8, + COM3 = 0x3e8, + COM4 = 0x2e8, + }; + + /*! \brief Transmission speed + * + * The unit Baud describes the transmission speed in number of symbols per + * seconds. 1 Baud therefore equals the transmission of 1 symbol per second. + * The possible Baud rates are whole-number dividers of the clock frequency + * of 115200 Hz.. + */ + enum class BaudRate : uint16_t { + B300 = 384, + B600 = 192, + B1200 = 96, + B2400 = 48, + B4800 = 24, + B9600 = 12, + B19200 = 6, + B38400 = 3, + B57600 = 2, + B115200 = 1, + }; + + /*! \brief Number of data bits per character */ + enum class DataBits : uint8_t { + D5 = 0, + D6 = 1, + D7 = 2, + D8 = 3, + }; + + /*! \brief Number of stop bits per character */ + enum class StopBits : uint8_t { + S1 = 0, + S1_5 = 4, + S2 = 4, + }; + + /*! \brief parity bit */ + enum class Parity : uint8_t { + NONE = 0, + ODD = 8, + EVEN = 24, + MARK = 40, + SPACE = 56, + }; + + private: + /*! \brief register index */ + enum class RegisterIndex : uint8_t { + RECEIVE_BUFFER = 0, + TRANSMIT_BUFFER = 0, + INTERRUPT_ENABLE = 1, + DIVISOR_LOW = 0, + DIVISOR_HIGH = 1, + INTERRUPT_IDENT = 2, + FIFO_CONTROL = 2, + LINE_CONTROL = 3, + MODEM_CONTROL = 4, + LINE_STATUS = 5, + MODEM_STATUS = 6 + }; + + /*! \brief Mask for the respective register */ + enum class RegisterMask : uint8_t { + RECEIVED_DATA_AVAILABLE = 1 << 0, + TRANSMITTER_HOLDING_REGISTER_EMPTY = 1 << 1, + RECEIVER_LINE_STATUS = 1 << 2, + MODEM_STATUS = 1 << 3, + + // Interrupt Ident Register + INTERRUPT_PENDING = 1 << 0, ///< 0 means interrupt pending + INTERRUPT_ID_0 = 1 << 1, + INTERRUPT_ID_1 = 1 << 2, + + // FIFO Control Register + ENABLE_FIFO = 1 << 0, ///< 0 means disabled ^= conforming to 8250a + CLEAR_RECEIVE_FIFO = 1 << 1, + CLEAR_TRANSMIT_FIFO = 1 << 2, + DMA_MODE_SELECT = 1 << 3, + TRIGGER_RECEIVE = 1 << 6, + + // Line Control Register + // bits per character: 5 6 7 8 + WORD_LENGTH_SELECT_0 = 1 << 0, // Setting Select0: 0 1 0 1 + WORD_LENGTH_SELECT_1 = 1 << 1, // Setting Select1: 0 0 1 1 + NUMBER_OF_STOP_BITS = 1 << 2, // 0 ≙ one stop bit, 1 ≙ 1.5/2 stop bits + PARITY_ENABLE = 1 << 3, + EVEN_PARITY_SELECT = 1 << 4, + STICK_PARITY = 1 << 5, + SET_BREAK = 1 << 6, + DIVISOR_LATCH_ACCESS_BIT = 1 << 7, // DLAB + + // Modem Control Register + DATA_TERMINAL_READY = 1 << 0, + REQUEST_TO_SEND = 1 << 1, + OUT_1 = 1 << 2, + OUT_2 = 1 << 3, // must be set for interrupts! + LOOP = 1 << 4, + + // Line Status Register + DATA_READY = 1 << 0, // Set when there is a value in the receive buffer + OVERRUN_ERROR = 1 << 1, + PARITY_ERROR = 1 << 2, + FRAMING_ERROR = 1 << 3, + BREAK_INTERRUPT = 1 << 4, + TRANSMITTER_HOLDING_REGISTER = 1 << 5, + TRANSMITTER_EMPTY = 1 << 6, // Send buffer empty (ready to send) + + // Modem Status Register + DELTA_CLEAR_TO_SEND = 1 << 0, + DELTA_DATA_SET_READY = 1 << 1, + TRAILING_EDGE_RING_INDICATOR = 1 << 2, + DELTA_DATA_CARRIER_DETECT = 1 << 3, + CLEAR_TO_SEND = 1 << 4, + DATA_SET_READY = 1 << 5, + RING_INDICATOR = 1 << 6, + DATA_CARRIER_DETECT = 1 << 7 + }; + + /*! \brief Read value from register + * + * + * \param reg Register index + * \return The value read from register + */ + uint8_t readReg(RegisterIndex reg); + + /*! \brief Write value to register + * + * + * \param reg Register index + * \param out value to be written + */ + void writeReg(RegisterIndex reg, uint8_t out); + + protected: + /*! \brief Selected COM port */ + const ComPort port; + + public: + /*! \brief Constructor + * + * Creates a Serial object that encapsulates the used COM port, as well as + * the parameters used for the serial connection. Default values are `8N1` + * (8 bit, no parity bit, one stop bit) with 115200 Baud using COM1. + * + */ + explicit Serial(ComPort port = ComPort::COM1, + BaudRate baud_rate = BaudRate::B115200, + DataBits data_bits = DataBits::D8, + StopBits stop_bits = StopBits::S1, + Parity parity = Parity::NONE); + + /*! \brief Write one byte to the serial interface + * + * + * \param out Byte to be written + * \return Byte written (or `-1` if writing byte failed) + */ + int write(uint8_t out); +}; diff --git a/kernel/arch/system.cc b/kernel/arch/system.cc new file mode 100644 index 0000000..96bc37b --- /dev/null +++ b/kernel/arch/system.cc @@ -0,0 +1,16 @@ +#include "system.h" + +#include "../debug/output.h" +#include "cmos.h" +#include "ioport.h" + +namespace System { + +void reboot() { + const IOPort system_control_port_a(0x92); + DBG_VERBOSE << "rebooting smp" << endl; + CMOS::write(CMOS::Register::STATUS_SHUTDOWN, 0); + system_control_port_a.outb(0x3); +} + +} // namespace System diff --git a/kernel/arch/system.h b/kernel/arch/system.h new file mode 100644 index 0000000..47c6191 --- /dev/null +++ b/kernel/arch/system.h @@ -0,0 +1,15 @@ +/*! \file + * \brief General \ref System functionality (\ref System::reboot "reboot") + */ + +#pragma once +#include "../types.h" + +/*! \brief General System functions + */ +namespace System { + +/*! \brief Perform a reboot + */ +void reboot(); +} // namespace System diff --git a/kernel/arch/textwindow.cc b/kernel/arch/textwindow.cc new file mode 100644 index 0000000..27e14ce --- /dev/null +++ b/kernel/arch/textwindow.cc @@ -0,0 +1,129 @@ +#include "textwindow.h" + +#include "../utils/math.h" + +TextWindow::TextWindow(unsigned from_col, unsigned to_col, unsigned from_row, + unsigned to_row, bool use_cursor) + : from_col(from_col), + to_col(to_col), + from_row(from_row), + to_row(to_row), + use_cursor(use_cursor), + pos_x(from_col), + pos_y(from_row) { + if (to_col > from_col && to_row > from_row) { + reset(); + } +} + +void TextWindow::setPos(unsigned rel_x, unsigned rel_y) { + unsigned abs_x = rel_x + from_col; + unsigned abs_y = rel_y + from_row; + + // Check if visible + if (abs_x < to_col && abs_y < to_row) { + if (use_cursor) { + CGA::setCursor(abs_x, abs_y); + } else { + pos_x = abs_x; + pos_y = abs_y; + } + } +} + +void TextWindow::getPos(unsigned& rel_x, unsigned& rel_y) const { + unsigned abs_x = pos_x; + unsigned abs_y = pos_y; + + if (use_cursor) { + CGA::getCursor(abs_x, abs_y); + } + + rel_x = Math::min(Math::max(abs_x, from_col), to_col - 1) - from_col; + rel_y = Math::min(Math::max(abs_y, from_row), to_row - 1) - from_row; +} + +void TextWindow::setPos(int rel_x, int rel_y) { + int x = rel_x < 0 ? rel_x + to_col - from_col : rel_x; + int y = rel_y < 0 ? rel_y + to_row - from_row : rel_y; + + if (x >= 0 && y >= 0) { + setPos(static_cast(x), static_cast(y)); + } +} + +void TextWindow::getPos(int& rel_x, int& rel_y) const { + unsigned x; + unsigned y; + getPos(x, y); + rel_x = static_cast(x); + rel_y = static_cast(y); +} + +void TextWindow::print(const char* str, size_t length, CGA::Attribute attrib) { + // Get position + unsigned abs_x = pos_x; + unsigned abs_y = pos_y; + + if (use_cursor) { + CGA::getCursor(abs_x, abs_y); + } + + // Print each character + while (length > 0) { + switch (*str) { + case '\n': + abs_x = from_col; + abs_y++; + break; + + case '\r': + abs_x = from_col; + break; + + default: + show(abs_x, abs_y, *str, attrib); + abs_x++; + if (abs_x >= to_col) { + abs_x = from_col; + abs_y++; + } + break; + } + str++; + if (abs_y >= to_row) { + scrollUp(); + abs_y--; + } + length--; + } + // Write position back + if (use_cursor) { + CGA::setCursor(abs_x, abs_y); + } else { + pos_x = abs_x; + pos_y = abs_y; + } +} + +void TextWindow::reset(char character, CGA::Attribute attrib) { + for (unsigned abs_y = from_row; abs_y < to_row; ++abs_y) { + for (unsigned abs_x = from_col; abs_x < to_col; ++abs_x) { + show(abs_x, abs_y, character, attrib); + } + } + setPos(0, 0); +} + +void TextWindow::scrollUp() const { + for (unsigned y = from_row + 1; y < to_row; ++y) { + for (unsigned x = from_col; x < to_col; ++x) { + unsigned pos = (y * CGA::COLUMNS) + x; + show(x, y - 1, CGA::TEXT_BUFFER_BASE[pos].character, + CGA::TEXT_BUFFER_BASE[pos].attribute); + } + } + for (unsigned x = from_col; x < to_col; ++x) { + CGA::show(x, to_row - 1, ' '); + } +} diff --git a/kernel/arch/textwindow.h b/kernel/arch/textwindow.h new file mode 100644 index 0000000..b5be906 --- /dev/null +++ b/kernel/arch/textwindow.h @@ -0,0 +1,168 @@ +/*! \file + * \brief \ref TextWindow provides virtual output windows in text mode + */ + +#pragma once +#include "../types.h" +#include "cga.h" + +/*! \brief Virtual windows in text mode + * \ingroup io + * + * Outputs text on a part of the screen in \ref CGA, + * a window is defined in by position and size (with its own cursor). + * + * This allows to separate the output of the application from the debug output + * on the screen without having to synchronize. + */ +class TextWindow { + // Prevent copies and assignments + TextWindow(const TextWindow&) = delete; + TextWindow& operator=(const TextWindow&) = delete; + + /*! \brief Scroll the contents of a window a line up + * + * Moves the screen content up one line. + * The new line at the bottom of the screen is filled with blanks. + */ + void scrollUp() const; + + protected: + /*! \brief Start column position (inclusive) of window + */ + unsigned from_col; + + /*! \brief End column position (exclusive) of window + */ + unsigned to_col; + + /*! \brief Start row position (inclusive) of window + */ + unsigned from_row; + + /*! \brief End row position (exclusive) of window + */ + unsigned to_row; + + /*! \brief use hardware cursor + * + * otherwise the position is stored in local variables + */ + bool use_cursor; + + /*! \brief Software cursor column + */ + unsigned pos_x; + + /*! \brief Software cursor row + */ + unsigned pos_y; + + public: + /*! \brief Constructor of a text window + * + * Creates a virtual, rectangular text window on the screen. + * The coordinates to construct the window are absolute positions in the + * \ref CGA screen. + * + * \note Overlapping windows are neither supported nor prevented -- better + * just try to avoid construction windows with overlapping + * coordinates! + * + * \warning Don't use the hardware cursor in more than one window! + * + * \param from_col Text Window starts in column `from_col`, + * the first (leftmost) possible column is `0` + * \param to_col Text Window extends to the right to column `to_col` + * (exclusive). This column has to be strictly greater than `from_col`, the + * maximum allowed value is \ref CGA::COLUMNS (rightmost) + * \param from_row Text Window starts in row `from_row`, + * the first possible (uppermost) row is `0` + * \param to_row Text Window extends down to row `to_row` (exclusive). + * This row has to be strictly greater than `from_row`, + * the maximum allowed value is \ref CGA::ROWS + * (bottom-most) + * \param use_cursor Specifies whether the hardware cursor (`true`) or a + * software cursor/variable (`false`) should be used to + * store the current position + * + */ + TextWindow(unsigned from_col, unsigned to_col, unsigned from_row, + unsigned to_row, bool use_cursor = false); + + /*! \brief Set the cursor position in the window + * + * Depending on the constructor parameter `use_cursor` either the + * hardware cursor (and only the hardware cursor!) is used or the position + * is stored internally in the object. + * + * The coordinates are relative to the upper left starting position of + * the window. + * + * \param rel_x Column in window + * \param rel_y Row in window + * cursor + */ + void setPos(unsigned rel_x, unsigned rel_y); + + /*! \brief Set the cursor position in the window + * + * Depending on the constructor parameter `use_cursor` either the + * hardware cursor (and only the hardware cursor!) is used or the position + * is stored internally in the object. + * + * The coordinates are relative to the upper left starting position of + * the window. + * Negative coordinates are interpreted relative to the right and bottom + * border of the window. + * + * \ref setPos(unsigned, unsigned)) + */ + void setPos(int rel_x, int rel_y); + + /*! \brief Get the current cursor position in the window + * + * Depending on the constructor parameter `use_cursor` either the + * hardware cursor (and only the hardware cursor!) is used or the position + * is retrieved from the internally stored object. + * + * \param rel_x Column in window + * \param rel_y Row in window + * cursor + */ + void getPos(unsigned& rel_x, unsigned& rel_y) const; + + /// \copydoc TextWindow::getPos(unsigned&,unsigned&) const + void getPos(int& rel_x, int& rel_y) const; + + /*! \brief Display multiple characters in the window + * + * Output a character string, starting at the current cursor position. + * Since the string does not need to contain a `\0` termination (unlike the + * common C string), a length parameter is required to specify the number + * of characters in the string. + * When the output is complete, the cursor is positioned after the last + * printed character. + * The same attributes (colors) are used for the entire text. + * + * If there is not enough space left at the end of the line, + * the output continues on the following line. + * As soon as the last window line is filled, the entire window area is + * moved up one line: The first line disappears, the bottom line is cleared. + * + * A line break also occurs whenever the character `\n` appears in the text. + * + * \param string Text to be printed + * \param length Length of text + * \param attrib Attribute for text + */ + void print(const char* string, size_t length, + CGA::Attribute attrib = CGA::Attribute()); // NOLINT + + /*! \brief Delete all contents in the window and reset the cursor. + * + * \param character Fill character + * \param attrib Attribute for fill character + */ + void reset(char character = ' ', CGA::Attribute attrib = CGA::Attribute()); +}; diff --git a/kernel/arch/tss.h b/kernel/arch/tss.h new file mode 100644 index 0000000..c2daa76 --- /dev/null +++ b/kernel/arch/tss.h @@ -0,0 +1,49 @@ + +/*! \file + * \brief Task State Segment + */ + +#pragma once +#include "../types.h" + +/*! \brief Task State Segment + */ +namespace TSS { + +/*! \brief TSS Format structure + * + * \see [ISDMv3 7.7 Task Management in 64-bit](intel_manual_vol3.pdf#page=252) + */ +struct Entry { + uint32_t : 32; + void* sp0; ///< Saves the stack pointer for every ring + void* sp1; + void* sp2; + uint64_t : 64; + void* ist1; + void* + ist2; ///< Interrupt Stack Table, stack pointer used by the instruction + void* ist3; ///< handlers when the interrupt descriptor table (IDT) is set + ///< up accordingly: + void* ist4; ///< If IST is set to a non-zero value (i.e., 1 - 7), + void* ist5; ///< the CPU automagically locals the respective value into the + ///< RSP. + void* ist6; ///< + void* ist7; ///< See https://wiki.osdev.org/Task_State_Segment + uint64_t : 64; + uint32_t : 16; + uint32_t iomap_base : 16; ///< Offset to IO Permission Bitmap +} __attribute__((packed)); + +static_assert(sizeof(Entry) == 104, "TaskStateSegment Entry has wrong size"); + +/*! \brief Initialize TSS for active core + */ +void init(); + +/*! \brief Set initial stack pointer in TSS + * \param ptr New (next) stack pointer + */ +void setStackpointer(void* ptr); + +} // namespace TSS diff --git a/kernel/assets/cat.h b/kernel/assets/cat.h new file mode 100644 index 0000000..a76cc75 --- /dev/null +++ b/kernel/assets/cat.h @@ -0,0 +1,4420 @@ + +constexpr unsigned char __cat_png[] = { +0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, +0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x01, 0x88, 0x00, 0x00, 0x09, 0x54, +0x08, 0x06, 0x00, 0x00, 0x00, 0x0d, 0x50, 0xe5, 0x15, 0x00, 0x00, 0xce, +0xb7, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0xed, 0x9d, 0xc9, 0x95, 0xdc, +0x38, 0x12, 0x86, 0x21, 0x5d, 0x74, 0x4e, 0x27, 0xf2, 0x28, 0x1b, 0xe8, +0x85, 0x6e, 0xf4, 0x85, 0xd6, 0xcc, 0x49, 0x86, 0x8c, 0x03, 0xb2, 0x63, +0x0c, 0xd0, 0xeb, 0x1a, 0x45, 0x36, 0xa2, 0x14, 0x85, 0x22, 0x33, 0xb9, +0x60, 0xc7, 0xf7, 0xbd, 0x17, 0x4f, 0xdd, 0x5a, 0xaa, 0xb2, 0x48, 0x00, +0x3f, 0x62, 0x41, 0xc0, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xeb, 0xdc, 0x78, 0x04, +0x00, 0x00, 0x10, 0x72, 0xff, 0x63, 0x33, 0x8f, 0x01, 0x00, 0x00, 0x42, +0x16, 0x04, 0x02, 0x00, 0x00, 0x3e, 0x79, 0x0f, 0x5f, 0xbe, 0x7c, 0xf9, +0xaf, 0x23, 0xc4, 0x04, 0x00, 0x00, 0x16, 0x11, 0x87, 0x6f, 0xdf, 0xbe, +0xfd, 0x8f, 0x27, 0x01, 0x00, 0x00, 0xca, 0xed, 0xeb, 0xd7, 0xaf, 0xff, +0xf9, 0xf3, 0xeb, 0x9b, 0xf7, 0x20, 0x00, 0x00, 0x00, 0xdc, 0xe4, 0x45, +0xe1, 0x4d, 0xcc, 0x0b, 0x05, 0x00, 0x00, 0x0c, 0x8c, 0x54, 0x2b, 0x2d, +0x2a, 0x0c, 0x08, 0x04, 0x00, 0x00, 0x3c, 0x84, 0xc1, 0xe7, 0x1a, 0xde, +0x56, 0x6c, 0xe1, 0x11, 0x01, 0x00, 0x8c, 0xc5, 0xf4, 0x42, 0x18, 0xd4, +0x26, 0x1e, 0x15, 0x00, 0xc0, 0x20, 0xc2, 0xa0, 0x09, 0xe8, 0x57, 0x46, +0x82, 0x1a, 0x00, 0x60, 0x10, 0x61, 0xb0, 0xc9, 0xe7, 0x3d, 0x46, 0xfe, +0x01, 0x00, 0x00, 0x61, 0xd8, 0x32, 0x4e, 0x50, 0x03, 0x00, 0x74, 0xc8, +0x7d, 0x6f, 0x28, 0xc9, 0x11, 0x5e, 0x02, 0x00, 0x18, 0xc7, 0x6b, 0xd8, +0x91, 0x7c, 0x7e, 0x65, 0x54, 0x2f, 0x01, 0x00, 0x74, 0x84, 0xf4, 0x4c, +0x5a, 0x22, 0x88, 0x43, 0xea, 0xf0, 0xd2, 0xe4, 0xfe, 0x2d, 0xaf, 0x05, +0x00, 0x80, 0x1c, 0x5e, 0xc3, 0x85, 0x5c, 0xc3, 0x07, 0xf3, 0x02, 0x93, +0xaa, 0x41, 0xdf, 0xcd, 0x7f, 0x4e, 0x04, 0x02, 0x00, 0x20, 0x03, 0x73, +0x24, 0xaf, 0x21, 0x65, 0xf5, 0xd2, 0xc3, 0xbb, 0xf1, 0xe2, 0x40, 0xf8, +0x0a, 0x00, 0x20, 0x03, 0xcb, 0xf7, 0xef, 0xdf, 0xff, 0x11, 0x8b, 0xe8, +0x3d, 0xdc, 0x9f, 0x2c, 0xf2, 0xf7, 0x1d, 0x36, 0x1b, 0x5b, 0x4c, 0x57, +0x58, 0x72, 0x1b, 0x00, 0x00, 0x39, 0x90, 0x9d, 0xfe, 0x8f, 0x1f, 0x3f, +0xfe, 0x59, 0x96, 0x25, 0x8a, 0xe7, 0x20, 0x26, 0x5f, 0x4f, 0x2c, 0x10, +0x89, 0xc7, 0xe1, 0xba, 0x48, 0x5e, 0xca, 0xc4, 0x9b, 0x03, 0x00, 0x48, +0x2c, 0x0e, 0x22, 0x0c, 0xbf, 0x7e, 0xfd, 0x7a, 0x8b, 0x15, 0x5e, 0x12, +0x61, 0xf8, 0xfd, 0xfb, 0xf7, 0x9b, 0x98, 0x17, 0x9d, 0xc5, 0xad, 0x34, +0xf0, 0x73, 0x94, 0xce, 0x02, 0x00, 0x54, 0xcb, 0xa2, 0x8b, 0x79, 0xac, +0xd0, 0x92, 0x98, 0x7c, 0x2d, 0xf5, 0x48, 0x44, 0x78, 0xc4, 0xbc, 0x37, +0x11, 0xcb, 0x43, 0x21, 0xbc, 0x04, 0x00, 0x90, 0x43, 0x1c, 0x22, 0x2f, +0xde, 0x9f, 0x72, 0x11, 0x3f, 0x7f, 0xfe, 0x7c, 0x78, 0x13, 0xf2, 0xab, +0xab, 0xbb, 0x32, 0x0a, 0x00, 0x60, 0x78, 0x26, 0xd9, 0xe5, 0xcb, 0xa2, +0x2d, 0xbb, 0xfb, 0x54, 0xe2, 0x60, 0x4d, 0xbc, 0x89, 0x48, 0x22, 0x41, +0xdb, 0x0e, 0x00, 0x80, 0x44, 0x3c, 0xce, 0x0f, 0xe8, 0xae, 0x3e, 0x66, +0x68, 0xc9, 0xed, 0xcc, 0x4d, 0x9c, 0x4d, 0x86, 0xd3, 0xf4, 0x0f, 0x00, +0x20, 0x2d, 0x8b, 0xee, 0xe6, 0x73, 0x79, 0x0f, 0x6b, 0x22, 0x71, 0x34, +0xac, 0xe5, 0x13, 0xd3, 0x84, 0x96, 0x00, 0x00, 0x12, 0xf1, 0x1e, 0x5a, +0xca, 0xed, 0x3d, 0x84, 0x22, 0x71, 0x42, 0x9c, 0x26, 0x5e, 0x1f, 0x00, +0x40, 0x1a, 0x1e, 0xa1, 0x25, 0x59, 0x98, 0xaf, 0x84, 0x79, 0x5c, 0xc4, +0x9c, 0xc4, 0x81, 0xcf, 0x40, 0xde, 0x01, 0x00, 0x20, 0x15, 0x7a, 0xde, +0x21, 0x56, 0x35, 0x51, 0x2c, 0x91, 0xd8, 0xe1, 0xc5, 0x20, 0x0e, 0x00, +0x00, 0x09, 0x79, 0x2f, 0x69, 0x8d, 0x79, 0x20, 0xce, 0x45, 0x28, 0x59, +0xdd, 0xca, 0x45, 0xf8, 0xcf, 0x88, 0x38, 0x00, 0x00, 0x24, 0x64, 0xae, +0x21, 0xef, 0xe0, 0x9e, 0x9f, 0x6b, 0x08, 0xff, 0x5f, 0x0e, 0xc2, 0x91, +0x90, 0x06, 0x00, 0x48, 0xe9, 0x39, 0x88, 0x20, 0x68, 0xde, 0x21, 0xe5, +0x81, 0x38, 0x17, 0xa7, 0xb7, 0xd2, 0x84, 0x30, 0x00, 0x00, 0x64, 0x10, +0x07, 0x1b, 0x56, 0xaa, 0xcd, 0x73, 0x70, 0xb4, 0xcf, 0x00, 0x00, 0x28, +0xc2, 0xa3, 0x9c, 0x55, 0x92, 0xc0, 0x22, 0x12, 0xb5, 0xe4, 0x1c, 0x1c, +0x2d, 0x34, 0x00, 0x00, 0x8a, 0x71, 0xf3, 0xa7, 0x8d, 0xab, 0xf4, 0x18, +0x76, 0xdc, 0x37, 0x31, 0xf1, 0x0a, 0x01, 0x00, 0xe2, 0x33, 0xc7, 0xba, +0x2a, 0xd4, 0x25, 0x3c, 0x20, 0xf7, 0xe2, 0xec, 0x03, 0x61, 0x26, 0x00, +0x80, 0x48, 0xc8, 0x8e, 0x7b, 0xa9, 0x59, 0x18, 0x6c, 0x78, 0x4b, 0xdb, +0x7f, 0x3b, 0xee, 0x79, 0x00, 0x00, 0x18, 0x53, 0x14, 0x42, 0x41, 0x50, +0x91, 0x90, 0x03, 0x7a, 0xcf, 0x04, 0xe2, 0xc5, 0x35, 0xa5, 0x00, 0x00, +0xb0, 0x25, 0x0c, 0x2d, 0x88, 0x82, 0x5b, 0xb9, 0x55, 0x4e, 0xf3, 0x0e, +0x5a, 0x6e, 0xfb, 0x22, 0x69, 0xce, 0xe1, 0x38, 0x00, 0x80, 0xbd, 0xc2, +0xa0, 0x89, 0xe7, 0x16, 0xc5, 0x41, 0x05, 0x42, 0x44, 0x61, 0xcf, 0x79, +0x0c, 0x5a, 0x7a, 0x03, 0x00, 0x74, 0x28, 0x0c, 0xce, 0x5c, 0x37, 0xaa, +0x62, 0xa0, 0x21, 0x25, 0x11, 0x08, 0x15, 0x8c, 0x67, 0xbd, 0xa0, 0x08, +0x33, 0x01, 0x00, 0x6c, 0x73, 0x6f, 0x51, 0x18, 0x74, 0x71, 0x17, 0x41, +0x10, 0x01, 0x10, 0x91, 0xd0, 0x5f, 0x55, 0x38, 0xf6, 0x08, 0x84, 0x23, +0xcc, 0x04, 0x00, 0xf0, 0x81, 0x9b, 0x7a, 0x0c, 0x2d, 0x1c, 0x6a, 0xdb, +0xf2, 0x1c, 0xd4, 0x6b, 0x58, 0x0b, 0x23, 0xd9, 0xb0, 0xd3, 0x8e, 0xbb, +0x20, 0x28, 0x77, 0x05, 0x00, 0x84, 0x41, 0x76, 0xcb, 0xad, 0x8a, 0x82, +0x5b, 0xb9, 0x73, 0x7a, 0x4b, 0x04, 0x8e, 0x08, 0x04, 0x79, 0x08, 0x80, +0xb2, 0x8b, 0xd2, 0x7d, 0x87, 0xd1, 0xf6, 0x20, 0xed, 0x3b, 0x58, 0x7a, +0x10, 0x86, 0x2d, 0x81, 0xd0, 0x50, 0x92, 0xfe, 0x8c, 0x47, 0x04, 0x82, +0x3c, 0x04, 0x40, 0x9c, 0x85, 0x7d, 0xb6, 0x26, 0x3b, 0xaf, 0x2d, 0x93, +0x12, 0x49, 0x99, 0x78, 0xd6, 0x5e, 0x4d, 0x52, 0xf9, 0x37, 0x7e, 0x37, +0xb7, 0xf8, 0xef, 0x31, 0x3d, 0x11, 0x14, 0x78, 0xcd, 0xbd, 0x37, 0x61, +0x70, 0x2b, 0xe7, 0x1e, 0x42, 0x4f, 0x22, 0xfc, 0xfd, 0x3d, 0x17, 0x16, +0xe1, 0x45, 0x00, 0x3c, 0x09, 0x3b, 0x38, 0x7f, 0x18, 0x2a, 0x5c, 0xd4, +0x6b, 0x5d, 0x5c, 0xe4, 0x73, 0xf9, 0x49, 0x3d, 0xe3, 0x81, 0x7c, 0x16, +0x86, 0x56, 0x13, 0xcf, 0xee, 0x64, 0x3e, 0x42, 0x44, 0x41, 0x0f, 0xc6, +0xa9, 0x69, 0xd2, 0x7a, 0xef, 0x18, 0x46, 0x24, 0x00, 0x31, 0x30, 0x3b, +0x7f, 0x15, 0x84, 0x96, 0x17, 0x06, 0x59, 0x00, 0xd4, 0xe4, 0xff, 0xe5, +0x67, 0x32, 0x9e, 0xc8, 0x3c, 0x98, 0xb7, 0x71, 0x0f, 0x13, 0xcf, 0xaf, +0x44, 0xbe, 0xe6, 0x4d, 0x80, 0xa3, 0x0d, 0x38, 0x40, 0x72, 0x41, 0x98, +0xac, 0x77, 0xd0, 0xeb, 0x0e, 0xd2, 0x0a, 0x85, 0xec, 0x1c, 0xd5, 0xb4, +0x05, 0xb5, 0x8a, 0x87, 0x8a, 0xa3, 0x09, 0x63, 0xdd, 0x3a, 0x78, 0xc7, +0xb3, 0x0a, 0x83, 0xfd, 0xf9, 0xf5, 0x0e, 0xe6, 0x67, 0xef, 0x5d, 0x9f, +0xdd, 0x91, 0x7f, 0xd3, 0xbb, 0xf9, 0xf1, 0x81, 0x47, 0x0a, 0x5d, 0x89, +0xc0, 0x7b, 0x5e, 0x40, 0x77, 0xd1, 0xa3, 0x4e, 0x72, 0xf9, 0xb9, 0x75, +0xe1, 0xb3, 0xf1, 0xe8, 0x30, 0xfc, 0xa0, 0xe2, 0xb1, 0x21, 0x1c, 0x35, +0xe6, 0x3a, 0xde, 0x05, 0x5f, 0xdf, 0x73, 0x28, 0x88, 0x1a, 0x56, 0x39, +0xda, 0x7e, 0xdb, 0x8a, 0x4b, 0x18, 0xcf, 0x1f, 0x71, 0x1c, 0xf9, 0x36, +0x23, 0xe4, 0xba, 0x00, 0xaf, 0x60, 0x44, 0xd1, 0xd0, 0x78, 0x75, 0x98, +0xe0, 0x54, 0xf1, 0x78, 0x21, 0x20, 0x53, 0xe2, 0x1d, 0xa6, 0x16, 0x08, +0xcc, 0x2a, 0x06, 0x6b, 0x71, 0x76, 0x9b, 0x84, 0x8d, 0x79, 0x51, 0x8f, +0x7e, 0x2f, 0xfb, 0x5c, 0xe4, 0x7b, 0x34, 0x70, 0x4b, 0x1c, 0x21, 0x27, +0x18, 0x92, 0xf7, 0x5d, 0x23, 0x82, 0x10, 0x5f, 0x38, 0x54, 0x34, 0xb6, +0x84, 0xc3, 0x2e, 0xc4, 0x2a, 0x1c, 0x2a, 0x1e, 0x81, 0x70, 0x84, 0xd5, +0x57, 0xcf, 0x7e, 0xb5, 0x15, 0x61, 0x8b, 0xbe, 0x5f, 0xb1, 0xad, 0xcf, +0x13, 0x7a, 0x3e, 0xa9, 0x43, 0x41, 0xf2, 0xf5, 0xad, 0x47, 0x21, 0xf6, +0xe2, 0x7e, 0x85, 0x2e, 0xc7, 0x07, 0xe1, 0x26, 0xa8, 0x8d, 0x3b, 0x82, +0x50, 0x47, 0x5e, 0x63, 0x8f, 0x70, 0x58, 0xf1, 0xb0, 0x22, 0x62, 0xc5, +0x64, 0xcd, 0xc2, 0x7f, 0xb3, 0xf5, 0x75, 0x35, 0x2f, 0x50, 0xea, 0x59, +0xd8, 0x5e, 0x47, 0xa3, 0x89, 0x04, 0x02, 0x01, 0x55, 0x89, 0x42, 0x4b, +0x2d, 0x96, 0x47, 0x0e, 0x55, 0xd9, 0xc4, 0xf8, 0xda, 0x82, 0x6f, 0xf3, +0x1d, 0x5b, 0xa2, 0x12, 0x86, 0xb7, 0x72, 0x7a, 0x07, 0x57, 0xbd, 0x89, +0x67, 0x1d, 0x52, 0x11, 0x08, 0x80, 0xc8, 0xf9, 0x04, 0x3c, 0x85, 0xbe, +0xbd, 0x91, 0x67, 0xd6, 0xd2, 0xbb, 0xd7, 0xdc, 0x84, 0xbd, 0x98, 0x67, +0x00, 0x9b, 0x58, 0xaa, 0x20, 0x97, 0x97, 0xf0, 0x88, 0x3f, 0x13, 0x3e, +0xc2, 0x5a, 0x35, 0x15, 0x89, 0x3d, 0x27, 0x94, 0x11, 0x08, 0x80, 0xd7, +0x1e, 0x02, 0x82, 0x80, 0x75, 0x65, 0xda, 0xeb, 0x68, 0x90, 0x50, 0x13, +0xe5, 0xae, 0x10, 0xd5, 0x4b, 0x48, 0x22, 0x08, 0x36, 0xfe, 0xcd, 0x22, +0x85, 0xd5, 0x20, 0x12, 0xb6, 0x41, 0x5e, 0x8f, 0x46, 0xfb, 0x0d, 0x88, +0xe5, 0x29, 0x24, 0xeb, 0x7f, 0x63, 0x4f, 0xbb, 0x8e, 0x92, 0x1c, 0xc4, +0xda, 0x11, 0x89, 0xce, 0x37, 0x2c, 0x84, 0x97, 0xe0, 0x34, 0xc9, 0x2e, +0x5d, 0xb1, 0xa2, 0x50, 0xba, 0xcc, 0x11, 0xc3, 0x46, 0x34, 0xbc, 0x07, +0x38, 0xeb, 0x2d, 0xcc, 0xa9, 0xca, 0x51, 0x6d, 0xeb, 0x84, 0x98, 0xa7, +0x63, 0x31, 0x0c, 0xa3, 0xbc, 0x15, 0x12, 0x0b, 0x43, 0xaa, 0x05, 0x5b, +0x0f, 0x23, 0x0d, 0xdc, 0xd2, 0x00, 0xc3, 0x6a, 0x32, 0xee, 0xa9, 0x86, +0xdd, 0x24, 0x3b, 0xa7, 0xa0, 0x77, 0xeb, 0x22, 0x0c, 0x18, 0x56, 0x55, +0xa3, 0x3e, 0x80, 0x72, 0xa1, 0x24, 0x3d, 0x99, 0x2a, 0xe2, 0x40, 0xe2, +0x19, 0xc3, 0x28, 0x6b, 0x85, 0x46, 0x84, 0x21, 0xf5, 0x99, 0x05, 0x7b, +0xd0, 0x88, 0x1c, 0x03, 0x86, 0xd1, 0xbd, 0x15, 0xda, 0x60, 0x4e, 0xb9, +0x60, 0xdb, 0xa6, 0x67, 0x78, 0x0d, 0x18, 0x46, 0x68, 0x09, 0xda, 0x20, +0xe9, 0x1d, 0xbe, 0xb6, 0xd1, 0x19, 0xb9, 0x06, 0x0c, 0xe3, 0x82, 0x20, +0xc0, 0x6b, 0xf8, 0x10, 0x4e, 0x1a, 0xb1, 0x97, 0x3e, 0x86, 0xb5, 0x60, +0x5c, 0x31, 0x0a, 0x6b, 0x4c, 0x29, 0xbd, 0x06, 0x7b, 0x7d, 0xa3, 0x84, +0x95, 0xf0, 0x1a, 0x30, 0xac, 0x4a, 0x61, 0x98, 0x58, 0x0a, 0xe1, 0x53, +0x12, 0x3a, 0xe5, 0xc0, 0xb3, 0x5e, 0x03, 0x89, 0x68, 0x0c, 0xab, 0xe7, +0xf0, 0x5b, 0x70, 0x6d, 0x2c, 0xc0, 0x47, 0xaf, 0x21, 0xe7, 0x15, 0x8d, +0x84, 0x94, 0x30, 0x2c, 0xcf, 0xc2, 0x2f, 0x39, 0x04, 0x7b, 0x77, 0x78, +0x70, 0x15, 0xac, 0x5e, 0x03, 0x4b, 0x18, 0x09, 0xd2, 0x87, 0x93, 0xac, +0xc8, 0xe8, 0x7f, 0xeb, 0x81, 0x37, 0xc4, 0x01, 0xc3, 0xa2, 0xcd, 0xb1, +0xc5, 0x27, 0x8e, 0x5f, 0x19, 0xc0, 0x29, 0xee, 0x7e, 0x90, 0xa5, 0xa8, +0x78, 0x58, 0x54, 0x78, 0x6c, 0x48, 0x09, 0x71, 0xc0, 0xb0, 0x8f, 0xed, +0xe9, 0x49, 0x1a, 0x43, 0x8d, 0x44, 0xaf, 0x4e, 0xf2, 0xc2, 0x30, 0xdb, +0x5c, 0x46, 0x78, 0xd9, 0xfc, 0x40, 0xb7, 0x6c, 0x61, 0xd8, 0xae, 0x62, +0x8d, 0x23, 0xf3, 0xd0, 0xcf, 0x31, 0xc4, 0x01, 0xd2, 0x79, 0x0d, 0x29, +0x92, 0xd0, 0xc1, 0xae, 0x66, 0x0a, 0x43, 0x4a, 0x78, 0x0e, 0x18, 0xb6, +0x9e, 0x97, 0x3b, 0x32, 0x2f, 0x68, 0xb1, 0x0d, 0xa9, 0x48, 0xd2, 0x6d, +0xd5, 0xef, 0x68, 0x26, 0xf3, 0x7d, 0x96, 0x30, 0xa4, 0x44, 0x3f, 0x25, +0x0c, 0xdb, 0x0e, 0x33, 0x1d, 0xf4, 0xaa, 0xe9, 0xa2, 0x0a, 0xf1, 0xc3, +0x49, 0x89, 0x9a, 0xea, 0x7d, 0xe8, 0xcb, 0xb2, 0x96, 0x6f, 0xe0, 0x8c, +0x03, 0x86, 0xbd, 0x2e, 0xfb, 0xde, 0x33, 0x47, 0x68, 0x75, 0x01, 0xd1, +0xc3, 0x49, 0x29, 0x84, 0xc1, 0x7b, 0x21, 0xe1, 0x4e, 0xe6, 0x93, 0xe7, +0x40, 0xbe, 0x01, 0xc3, 0xa2, 0x86, 0x99, 0x68, 0x94, 0x07, 0xd1, 0xc2, +0x49, 0x49, 0xee, 0x68, 0xf0, 0x31, 0xd0, 0xb0, 0x74, 0x6e, 0x46, 0x1c, +0x30, 0xec, 0xbc, 0xbd, 0x9a, 0x2f, 0x7e, 0x2e, 0x53, 0xb2, 0x0a, 0x97, +0x49, 0x22, 0x0c, 0x1b, 0x5e, 0xc3, 0x43, 0x1c, 0x24, 0xbf, 0x80, 0x38, +0x60, 0x58, 0xba, 0x30, 0x13, 0xc9, 0x69, 0xb8, 0xca, 0x94, 0xea, 0xf2, +0x9e, 0x27, 0x75, 0xd7, 0x84, 0x95, 0x30, 0x2c, 0x62, 0x6f, 0x32, 0x47, +0x72, 0x1a, 0x62, 0x87, 0x93, 0x52, 0xf5, 0x4e, 0xf2, 0x5e, 0xc3, 0xb4, +0xf6, 0x4d, 0xd7, 0xce, 0x38, 0x48, 0x42, 0x9a, 0xbe, 0x4a, 0x18, 0x76, +0x2e, 0x0f, 0xf1, 0x62, 0xfe, 0x4c, 0x2c, 0x75, 0x70, 0x94, 0xb9, 0x80, +0xd7, 0xf0, 0xf0, 0x1c, 0x10, 0x07, 0x0c, 0x8b, 0xbb, 0x19, 0xdb, 0xaa, +0xf8, 0xf3, 0xf3, 0x8a, 0xc3, 0x71, 0xb0, 0x3f, 0x9c, 0x94, 0xd8, 0x6b, +0xd8, 0x74, 0x67, 0xb7, 0x4e, 0x47, 0x23, 0x0e, 0x18, 0x76, 0xcd, 0x44, +0x20, 0x36, 0xaa, 0x99, 0xa8, 0x5e, 0x82, 0xb2, 0x1e, 0xc3, 0x0e, 0xaf, +0x61, 0xf5, 0x9c, 0x03, 0x39, 0x07, 0x0c, 0x8b, 0x57, 0xc9, 0x24, 0x22, +0x41, 0x78, 0x09, 0xaa, 0xf1, 0x18, 0xdc, 0xc7, 0xce, 0x90, 0xcf, 0x58, +0x4d, 0x48, 0xe3, 0x39, 0x60, 0x58, 0xdc, 0x7b, 0x52, 0x6c, 0x98, 0x89, +0xc3, 0x71, 0xf0, 0xd4, 0x63, 0x48, 0x7d, 0x79, 0xcf, 0x4a, 0xab, 0x8c, +0xd5, 0xcf, 0x11, 0x96, 0xb2, 0x92, 0x73, 0xc0, 0x5a, 0x89, 0xed, 0xb7, +0xf2, 0x59, 0x75, 0x8e, 0x05, 0x6d, 0x69, 0xf0, 0x1e, 0xe0, 0xb3, 0xc7, +0x90, 0x32, 0x94, 0xb4, 0x37, 0xa4, 0xa4, 0x9f, 0x05, 0x71, 0xc0, 0x5a, +0x16, 0x88, 0x56, 0xfa, 0x80, 0x89, 0xe7, 0xb0, 0x12, 0xb6, 0xe5, 0x70, +0x1c, 0xe4, 0x09, 0x25, 0xed, 0x4d, 0x44, 0x3f, 0xf3, 0x1c, 0x08, 0x2b, +0x61, 0x2d, 0x86, 0x6e, 0x5a, 0x10, 0x09, 0x99, 0x57, 0x76, 0x03, 0x46, +0x78, 0x09, 0x9c, 0xdf, 0xc1, 0xcf, 0x39, 0x3c, 0x06, 0xb7, 0xdd, 0x2a, +0x63, 0x35, 0xe7, 0x10, 0x8a, 0x03, 0xed, 0xba, 0xb1, 0x96, 0x13, 0xc0, +0xb5, 0x37, 0x8d, 0x54, 0x81, 0x30, 0x79, 0x08, 0xaa, 0x97, 0x06, 0x16, +0x85, 0x87, 0xb7, 0x90, 0x79, 0x37, 0xbe, 0x6b, 0xc0, 0x85, 0xa5, 0xac, +0xb4, 0xeb, 0xc6, 0x5a, 0x37, 0x19, 0xbf, 0x2d, 0x6c, 0x70, 0xf4, 0x0e, +0x15, 0x2f, 0x10, 0x84, 0x97, 0x10, 0x85, 0x6c, 0x89, 0xba, 0x3d, 0xc9, +0xae, 0x47, 0xf7, 0x57, 0x2b, 0x0e, 0x84, 0x94, 0x30, 0xbc, 0x88, 0xfc, +0x02, 0x41, 0xef, 0xa5, 0x31, 0x90, 0x1d, 0xc0, 0x5c, 0x42, 0x14, 0x4e, +0x84, 0x94, 0x26, 0xbd, 0xbc, 0x44, 0xc5, 0x01, 0xaf, 0x01, 0xeb, 0xcd, +0x8b, 0xa8, 0xfd, 0xdc, 0x8e, 0xce, 0x3f, 0x04, 0x82, 0x9c, 0x42, 0x2d, +0x5e, 0xc3, 0x23, 0xdf, 0xa0, 0x47, 0xfd, 0x11, 0x07, 0xac, 0x77, 0x2f, +0xa2, 0x66, 0x8f, 0x38, 0x38, 0x0b, 0x41, 0x7b, 0x8d, 0x8e, 0x3c, 0x85, +0x45, 0x44, 0xa1, 0x86, 0xc1, 0xb7, 0xb3, 0x7c, 0xf5, 0x21, 0x66, 0x5a, +0x35, 0x85, 0x38, 0x60, 0x23, 0x58, 0xed, 0x15, 0x4d, 0x08, 0x44, 0x47, +0x5e, 0x82, 0x2c, 0xae, 0xa5, 0x3d, 0x05, 0x77, 0xae, 0x7c, 0xf5, 0x11, +0x52, 0x92, 0xcf, 0x2e, 0x03, 0x51, 0xdd, 0x5a, 0xae, 0x07, 0xc5, 0x7a, +0xb7, 0x03, 0xb7, 0xb7, 0x15, 0x3d, 0x2c, 0x87, 0x40, 0x34, 0x2c, 0x08, +0x35, 0xba, 0xa8, 0x07, 0x6f, 0x9c, 0x5a, 0xb4, 0xaa, 0xc3, 0x96, 0xb0, +0x92, 0x8c, 0xc6, 0x46, 0xc9, 0x45, 0x20, 0x10, 0x70, 0x36, 0x54, 0x34, +0xf9, 0x5d, 0xf8, 0x52, 0xb3, 0x20, 0xb8, 0xcf, 0xe5, 0xab, 0x7b, 0x06, +0xd3, 0x6a, 0x95, 0x12, 0x5e, 0x03, 0x36, 0x9a, 0x17, 0x51, 0xeb, 0x98, +0x0f, 0xda, 0x6d, 0x50, 0xe6, 0x5a, 0x91, 0x87, 0xb0, 0xb4, 0xb6, 0x83, +0xde, 0xd9, 0x47, 0x49, 0x99, 0x6d, 0x38, 0x89, 0x83, 0x6f, 0xd8, 0xa8, +0x26, 0xf3, 0xbc, 0x76, 0x81, 0xf0, 0x73, 0x13, 0x81, 0xa8, 0x84, 0xa9, +0xa5, 0x01, 0xee, 0x13, 0xcb, 0x7b, 0x73, 0x0d, 0x77, 0xf9, 0xfb, 0x32, +0xf0, 0x48, 0x44, 0x63, 0xd8, 0x5f, 0x2f, 0x02, 0x81, 0x80, 0x6e, 0x04, +0xc2, 0xb4, 0xe4, 0x9e, 0x0e, 0xfc, 0x5c, 0x73, 0x78, 0xb6, 0xe1, 0xd5, +0xe5, 0xe8, 0x18, 0x36, 0x8a, 0x17, 0x81, 0x40, 0x40, 0xf3, 0x02, 0x61, +0x84, 0xe1, 0x48, 0xc2, 0xea, 0x93, 0xd7, 0x40, 0xbb, 0x0c, 0x0c, 0xfb, +0xe8, 0x41, 0xd4, 0x28, 0x12, 0x5a, 0x38, 0xe2, 0x05, 0x62, 0x62, 0x69, +0x46, 0x20, 0x9e, 0xe5, 0x17, 0x96, 0x13, 0xbb, 0x88, 0x4f, 0x5e, 0x03, +0xed, 0x32, 0x30, 0xac, 0x8d, 0x3c, 0x84, 0x0a, 0x84, 0x3f, 0xf1, 0x8d, +0x40, 0x54, 0xc2, 0xbd, 0x96, 0x41, 0xeb, 0xf3, 0x0b, 0x67, 0x06, 0xc6, +0x23, 0xd1, 0x2e, 0x83, 0x5e, 0xbd, 0x06, 0x2a, 0x94, 0x30, 0xac, 0xad, +0x3c, 0x84, 0x9d, 0xbb, 0x08, 0x44, 0x5d, 0x2c, 0x15, 0x78, 0x0b, 0x67, +0xeb, 0x9e, 0x1f, 0x5e, 0x83, 0xee, 0x3e, 0x9e, 0x5c, 0x7e, 0x8e, 0x61, +0x58, 0x03, 0xcd, 0xfa, 0x10, 0x88, 0x0a, 0xc9, 0x71, 0x59, 0x4f, 0x24, +0x6f, 0xe1, 0xdd, 0x6b, 0x90, 0xaf, 0x11, 0x7a, 0x0d, 0x84, 0x93, 0x30, +0x0c, 0x81, 0x80, 0x44, 0x9e, 0x44, 0xaa, 0x05, 0x36, 0xa8, 0x44, 0xba, +0x7a, 0x4a, 0xf2, 0xd1, 0x2a, 0xc3, 0x7a, 0x0d, 0x84, 0x93, 0x30, 0xac, +0x2b, 0x81, 0x98, 0x59, 0x8e, 0xeb, 0x24, 0xda, 0xc1, 0x39, 0x13, 0x3e, +0x8a, 0x21, 0x0a, 0xab, 0xb9, 0x06, 0xaa, 0x93, 0x30, 0xac, 0x8f, 0xc4, +0xb9, 0xad, 0x3a, 0x44, 0x20, 0xda, 0x10, 0x8a, 0xf7, 0xfb, 0x1c, 0xf6, +0x08, 0x86, 0x09, 0x1d, 0xcd, 0x2e, 0x7e, 0x1d, 0xf3, 0xa3, 0x55, 0x86, +0xd6, 0x4a, 0xe3, 0x35, 0x60, 0x58, 0x5f, 0x49, 0x73, 0x7b, 0x8b, 0xa3, +0xe3, 0xca, 0xd1, 0x26, 0x05, 0xc3, 0xf6, 0x6b, 0xb2, 0x36, 0xf9, 0x3f, +0x4b, 0xd5, 0x60, 0xeb, 0xc3, 0x85, 0x3e, 0xb5, 0x5f, 0x7c, 0x82, 0x61, +0xd8, 0xb9, 0x43, 0x72, 0x2a, 0x10, 0x5c, 0x1a, 0x04, 0xbb, 0xbc, 0x86, +0x30, 0x11, 0x4d, 0x48, 0x09, 0xc3, 0xfa, 0x33, 0xdb, 0x5d, 0x99, 0x8e, +0xae, 0xb0, 0x87, 0x39, 0xf4, 0x1a, 0x08, 0x29, 0x61, 0x58, 0xff, 0x1e, +0x84, 0xce, 0x77, 0xbc, 0x08, 0x78, 0xe9, 0x35, 0x90, 0x6b, 0xc0, 0xb0, +0x31, 0xbd, 0x08, 0x1f, 0x2d, 0x20, 0x59, 0x0d, 0xff, 0x7a, 0x0c, 0x2a, +0x0c, 0x32, 0x50, 0x64, 0x07, 0x41, 0x38, 0x29, 0xce, 0xce, 0x8c, 0xe7, +0x88, 0x21, 0x12, 0xd0, 0xa4, 0xb7, 0xe0, 0xfc, 0x7d, 0xd6, 0x7a, 0xcb, +0x5b, 0xed, 0xf7, 0xe6, 0xb6, 0x24, 0x0c, 0xb6, 0x27, 0x15, 0xcf, 0x14, +0x6b, 0x69, 0xec, 0xae, 0xb4, 0xe7, 0x47, 0x24, 0x06, 0x41, 0x12, 0x4f, +0x93, 0xf3, 0x57, 0x7f, 0xca, 0x22, 0x26, 0x86, 0x30, 0xc4, 0xad, 0x29, +0x0f, 0x77, 0x62, 0x1a, 0xd7, 0xe5, 0x19, 0x63, 0x2d, 0x0a, 0x85, 0x1f, +0xb7, 0x13, 0xcb, 0x67, 0xbf, 0xbc, 0x8b, 0x82, 0x7a, 0x0a, 0x88, 0x42, +0x1e, 0xa1, 0xb0, 0xbb, 0x31, 0xdb, 0xaf, 0x8a, 0xdc, 0x4e, 0xda, 0xba, +0x7e, 0x35, 0x3b, 0xde, 0x8f, 0x98, 0xcc, 0x0d, 0xfb, 0x75, 0xb6, 0x4c, +0xcf, 0x29, 0xd9, 0xff, 0xd6, 0xff, 0x0f, 0x4d, 0xc7, 0x85, 0x78, 0xed, +0xfe, 0x20, 0xab, 0x7e, 0x66, 0x2d, 0x59, 0xaf, 0xee, 0x39, 0xea, 0xf8, +0xf5, 0x9f, 0x1f, 0x4f, 0xa2, 0xb7, 0xdc, 0x82, 0x0c, 0x44, 0x79, 0xb9, +0x1a, 0x0f, 0xa7, 0x5f, 0x52, 0x1d, 0x42, 0xa1, 0x5e, 0x85, 0x8a, 0x05, +0xef, 0xe5, 0x75, 0x8b, 0x6c, 0x3b, 0x8e, 0xc3, 0xcd, 0x8e, 0x3c, 0xcb, +0xb5, 0x67, 0x1c, 0xdb, 0xb4, 0x78, 0xc3, 0x7a, 0xdf, 0x6b, 0xe2, 0x22, +0x39, 0x3d, 0x5f, 0x09, 0xb4, 0xb8, 0xbf, 0x1d, 0x0d, 0x26, 0xf7, 0xf7, +0x10, 0xab, 0x76, 0x72, 0xd6, 0x43, 0x69, 0x73, 0xad, 0x62, 0xab, 0xe1, +0x52, 0xc2, 0x4d, 0x9d, 0x85, 0x93, 0x58, 0x74, 0xda, 0x10, 0x0a, 0xeb, +0x59, 0xf4, 0x2a, 0xe2, 0x76, 0x27, 0xfd, 0x6c, 0x91, 0xdf, 0xb3, 0xd0, +0xeb, 0x22, 0x1d, 0x2e, 0xd6, 0xcf, 0x2c, 0x5c, 0xc4, 0xc3, 0xcf, 0xb1, +0x66, 0x6b, 0xde, 0x82, 0x7b, 0xde, 0xef, 0x6c, 0x76, 0xfb, 0xcf, 0x0f, +0xdc, 0xbd, 0x17, 0xf1, 0xfe, 0xdf, 0x81, 0x57, 0x51, 0x65, 0x02, 0xdb, +0x8b, 0x04, 0x27, 0xad, 0x3b, 0x60, 0x61, 0x61, 0x6e, 0x23, 0x89, 0xbd, +0x66, 0x36, 0x37, 0x64, 0x43, 0x14, 0xb5, 0x2f, 0xfa, 0x76, 0xa1, 0x3f, +0xba, 0xd8, 0x6f, 0x2d, 0xea, 0xfa, 0xb5, 0xcd, 0xae, 0xbc, 0xaa, 0xe7, +0xe0, 0x3f, 0xd3, 0xd1, 0xf6, 0x36, 0x93, 0x11, 0x08, 0xed, 0x94, 0xe0, +0xb4, 0xbd, 0x4e, 0xad, 0xe3, 0x56, 0x6f, 0x9d, 0x3b, 0xf9, 0x33, 0x43, +0x2d, 0xa1, 0x25, 0x16, 0xe2, 0xe3, 0xcd, 0x0d, 0xb5, 0x97, 0x55, 0xae, +0x45, 0x48, 0x85, 0x62, 0x6f, 0x68, 0x44, 0xbd, 0x8c, 0x5c, 0xc2, 0xf1, +0x6c, 0xf1, 0x3f, 0x12, 0xce, 0x09, 0x17, 0xff, 0x27, 0x61, 0x98, 0x97, +0x2d, 0x64, 0x6a, 0x12, 0x08, 0xe3, 0x35, 0x9c, 0xdd, 0xc0, 0x6d, 0xed, +0xc4, 0x1f, 0x15, 0x86, 0x35, 0x8a, 0xc5, 0xca, 0x19, 0x29, 0x92, 0xd7, +0x84, 0x96, 0xfa, 0x0d, 0xfb, 0x6c, 0xdc, 0x8d, 0x31, 0x95, 0xac, 0x1a, +0x89, 0x11, 0x17, 0xdf, 0x9b, 0x64, 0x55, 0x01, 0x38, 0x1a, 0xe6, 0x59, +0xfb, 0xde, 0xe1, 0x8e, 0x5f, 0xbe, 0xb6, 0x09, 0x9d, 0x2c, 0xee, 0x7a, +0xdf, 0xb0, 0xa5, 0xa6, 0x0d, 0xc5, 0xc5, 0x1d, 0xf4, 0x5e, 0x61, 0x89, +0xd6, 0xe1, 0x39, 0x71, 0xc8, 0x89, 0xd6, 0x1c, 0x2d, 0x50, 0xa3, 0x0b, +0x5e, 0xb1, 0x28, 0x6c, 0x0e, 0xea, 0x52, 0x13, 0x52, 0xbe, 0xaf, 0xf5, +0x2c, 0x72, 0x24, 0x5e, 0xf7, 0x86, 0x7f, 0x42, 0xef, 0xc5, 0xec, 0xfe, +0xd7, 0x76, 0xfd, 0xb1, 0x17, 0x8c, 0xa9, 0xa2, 0x71, 0x54, 0x22, 0x51, +0x5b, 0x9d, 0x50, 0x68, 0xc8, 0x49, 0xc6, 0x46, 0x04, 0xc1, 0x84, 0x0c, +0xdc, 0xf1, 0x1e, 0xa2, 0x5d, 0x98, 0xb4, 0xd4, 0xf2, 0xd9, 0x6d, 0xb9, +0xa6, 0x15, 0x8e, 0xa3, 0x02, 0x12, 0xfe, 0x3b, 0xb5, 0xad, 0x9d, 0xff, +0x0b, 0x01, 0xc8, 0xba, 0x38, 0x56, 0x94, 0xc0, 0x2d, 0x5d, 0xc5, 0xf3, +0xb8, 0x0a, 0xa0, 0x96, 0x79, 0xae, 0x55, 0x4e, 0x84, 0x9c, 0x1a, 0xa0, +0xe6, 0x2a, 0x88, 0x8a, 0xc2, 0x47, 0x5d, 0x85, 0xea, 0xc2, 0x9a, 0x7b, +0x0d, 0xe9, 0xac, 0x59, 0x10, 0xef, 0xb7, 0x71, 0xff, 0x94, 0x3b, 0xff, +0x2e, 0xbc, 0xe2, 0x8b, 0xf9, 0x86, 0x54, 0x4c, 0xb5, 0xe4, 0x29, 0x28, +0x85, 0xad, 0x9f, 0xc9, 0x91, 0x68, 0x8e, 0x7a, 0x8b, 0x5e, 0x83, 0xe1, +0xba, 0x1e, 0x77, 0x6f, 0xc5, 0x0b, 0x2e, 0x1a, 0xa8, 0xd8, 0xa9, 0xc2, +0xab, 0xd0, 0x3c, 0x9a, 0x78, 0xa3, 0x84, 0x9c, 0xd8, 0x65, 0xd5, 0xe4, +0x25, 0xcc, 0x89, 0x06, 0xe3, 0x82, 0x40, 0x0c, 0xef, 0x15, 0xb7, 0x54, +0xf3, 0x7f, 0x2f, 0xbd, 0x0e, 0xe8, 0x35, 0x01, 0x26, 0xe4, 0xc4, 0x99, +0x09, 0xbc, 0x87, 0x76, 0xbd, 0x84, 0xda, 0x77, 0xaf, 0x07, 0x43, 0x20, +0x37, 0xc6, 0x75, 0xd4, 0xe7, 0xd9, 0xaa, 0xe0, 0x3e, 0xca, 0x64, 0x4b, +0x7a, 0x14, 0x78, 0x13, 0x75, 0xd1, 0xed, 0xa1, 0xb8, 0x95, 0x12, 0x49, +0x84, 0xb7, 0xce, 0xe4, 0x69, 0x37, 0x5e, 0x71, 0x47, 0x0b, 0xda, 0xbd, +0xe4, 0xda, 0xb0, 0xe2, 0x4d, 0x90, 0x9b, 0x28, 0x11, 0x7f, 0xec, 0xad, +0x72, 0x29, 0x10, 0x05, 0x3c, 0xb3, 0x7d, 0x31, 0xf2, 0xde, 0x98, 0x0b, +0x3e, 0xcb, 0x1e, 0x3d, 0xb1, 0x62, 0x1e, 0x85, 0x96, 0x6d, 0xd3, 0xa6, +0x83, 0x45, 0xac, 0x07, 0x51, 0x68, 0xea, 0xd9, 0xfa, 0xe7, 0xd6, 0xdd, +0x21, 0xa5, 0x12, 0xde, 0xc3, 0x00, 0xd7, 0x6c, 0x8a, 0x47, 0x31, 0x97, +0xc8, 0xeb, 0x68, 0x2f, 0x32, 0xd3, 0xa6, 0x63, 0x62, 0xe9, 0x26, 0xbc, +0x54, 0x32, 0xc1, 0x3c, 0x8a, 0xf8, 0xf6, 0x38, 0xd1, 0xb2, 0x7b, 0xc5, +0x83, 0xdd, 0xc1, 0x7c, 0x2b, 0x25, 0x14, 0x7a, 0x6a, 0xdf, 0x24, 0xb0, +0x39, 0x81, 0x4d, 0x78, 0xe9, 0x93, 0x97, 0x30, 0x37, 0x32, 0x30, 0xaa, +0x4e, 0x52, 0x77, 0xbc, 0xa8, 0x2d, 0x0e, 0x2f, 0x2c, 0xdb, 0x18, 0xcf, +0x2d, 0x14, 0xf6, 0xe0, 0xa7, 0xff, 0xde, 0xe4, 0x26, 0x46, 0x5c, 0xc0, +0x1a, 0xf1, 0x12, 0xaa, 0x0a, 0x73, 0x1c, 0x5c, 0xd4, 0xba, 0x24, 0xe7, +0x82, 0x35, 0xb8, 0x38, 0x58, 0x8f, 0x22, 0x7b, 0x8e, 0xc2, 0xe6, 0x26, +0xe8, 0x0e, 0xdb, 0xf8, 0x44, 0x3a, 0x32, 0xe1, 0x8c, 0x28, 0x34, 0x3d, +0xf1, 0x6a, 0x15, 0x08, 0x3f, 0x91, 0x7b, 0x9d, 0x4c, 0x77, 0x3c, 0xb0, +0x72, 0xcf, 0x3e, 0xf7, 0x98, 0xb7, 0xb9, 0x09, 0xbc, 0x89, 0xb8, 0x4c, +0x35, 0x2c, 0x54, 0x41, 0x0b, 0x87, 0x09, 0x01, 0x46, 0x1c, 0x1a, 0x11, +0x65, 0xaa, 0x69, 0x2a, 0x0c, 0x3b, 0x99, 0x26, 0x90, 0x78, 0x13, 0x2d, +0xc5, 0x69, 0x03, 0xef, 0x20, 0xd7, 0x41, 0xb5, 0xa2, 0x6e, 0x77, 0x6d, +0xf9, 0x9d, 0x4e, 0x4b, 0x30, 0x4b, 0x3c, 0x73, 0xc4, 0xa1, 0x62, 0xa1, +0x08, 0xde, 0x13, 0x42, 0x51, 0xdb, 0x44, 0x0a, 0x2f, 0x64, 0x1f, 0xb4, +0x2c, 0xad, 0x9a, 0xfc, 0xce, 0x40, 0xae, 0x77, 0x72, 0x81, 0x20, 0xac, +0x74, 0x2e, 0x5a, 0x51, 0xca, 0x9b, 0xae, 0xb4, 0x49, 0xe2, 0x58, 0x8b, +0x97, 0x6d, 0x29, 0xad, 0xbd, 0xff, 0x07, 0x3f, 0xf9, 0x58, 0xdc, 0x7b, +0xd0, 0xf0, 0xdd, 0x60, 0xc2, 0x9c, 0xf4, 0xb9, 0x93, 0x90, 0xbe, 0xbe, +0xee, 0x94, 0x9a, 0x17, 0x03, 0x78, 0xcf, 0xf1, 0x88, 0x15, 0xa7, 0x55, +0x51, 0xb0, 0xf7, 0x05, 0x70, 0x43, 0x54, 0xd9, 0xe4, 0xb4, 0xb9, 0xbb, +0x62, 0x44, 0xd7, 0x3a, 0x59, 0x82, 0x1a, 0x71, 0x88, 0x27, 0xe2, 0xae, +0x40, 0xc5, 0x93, 0xd9, 0x30, 0xf1, 0x0e, 0x5f, 0xb9, 0x7b, 0x31, 0x1e, +0xb8, 0xf6, 0x6f, 0x57, 0x33, 0x55, 0x04, 0xd3, 0xe0, 0xcf, 0xf7, 0xee, +0xca, 0x79, 0x0e, 0xa3, 0xc7, 0x5c, 0x67, 0x47, 0x62, 0xbf, 0x99, 0x79, +0x52, 0xea, 0x44, 0x36, 0x21, 0xa7, 0xe7, 0x2c, 0x57, 0x1f, 0x70, 0x28, +0x0e, 0xa6, 0x0e, 0x79, 0x78, 0x75, 0x2e, 0xe1, 0x3d, 0xb0, 0x80, 0xc5, +0xdd, 0xfc, 0xb8, 0x7e, 0xba, 0xb2, 0x12, 0x76, 0x22, 0xe4, 0x74, 0xcc, +0xbd, 0xbb, 0xa2, 0xda, 0xa1, 0x38, 0xd0, 0x65, 0xf1, 0x33, 0x25, 0x06, +0xbb, 0xff, 0x9e, 0x90, 0xa6, 0x74, 0x9b, 0xb1, 0xdd, 0x69, 0xd8, 0x89, +0xb5, 0x2b, 0xf2, 0x04, 0xb2, 0xe2, 0xc0, 0x45, 0xe3, 0xf5, 0x08, 0x84, +0xa3, 0xf4, 0x32, 0x95, 0x40, 0xb0, 0x78, 0x64, 0x0e, 0x3b, 0xe5, 0xf4, +0xc0, 0x35, 0x87, 0xca, 0xdc, 0x89, 0x10, 0xfe, 0xb0, 0xc9, 0x68, 0xd3, +0x51, 0x11, 0x17, 0x2d, 0xa0, 0xe4, 0xe1, 0x38, 0x4e, 0x92, 0xc6, 0x13, +0x08, 0xca, 0x59, 0xcb, 0xbe, 0xc7, 0x5c, 0xf3, 0x48, 0x45, 0x82, 0xf5, +0xec, 0x42, 0xf2, 0x54, 0x72, 0x0c, 0x36, 0xdf, 0xe0, 0xe8, 0xa2, 0xf8, +0x8c, 0x5a, 0xee, 0x40, 0x9e, 0x10, 0x08, 0x6e, 0xd7, 0x6b, 0x3d, 0xec, +0xe4, 0x32, 0x85, 0x68, 0x45, 0x24, 0xfc, 0xda, 0x36, 0x6c, 0x44, 0xe4, +0xf4, 0xc3, 0x96, 0x5c, 0x83, 0x11, 0x07, 0xdc, 0xee, 0x84, 0xcf, 0x3a, +0x81, 0x50, 0xdc, 0x79, 0xee, 0xb4, 0x40, 0x6f, 0x59, 0xf4, 0x73, 0x85, +0x9d, 0x8c, 0x48, 0x8c, 0xf7, 0xfe, 0xcf, 0xba, 0x6c, 0x1a, 0x5a, 0x22, +0x56, 0x57, 0xef, 0xc0, 0x76, 0x9c, 0x8b, 0x88, 0x26, 0x10, 0x84, 0x96, +0xc6, 0xf5, 0xcc, 0xb5, 0x08, 0x67, 0x44, 0x91, 0xb8, 0x9f, 0x49, 0x9e, +0xca, 0xbf, 0xd1, 0x6a, 0xa5, 0x9e, 0xdb, 0x43, 0x67, 0x08, 0x7b, 0x2c, +0x35, 0x9c, 0xac, 0x1e, 0x20, 0xf4, 0x74, 0xb9, 0x84, 0x9b, 0xd0, 0x52, +0xdd, 0x73, 0x29, 0x75, 0x6e, 0x22, 0x10, 0x89, 0x61, 0xbc, 0xef, 0x53, +0x13, 0x47, 0x73, 0x0f, 0xc3, 0xba, 0x5d, 0x71, 0xb9, 0xf9, 0x01, 0xb7, +0x54, 0xd0, 0xe5, 0xb5, 0xd7, 0x30, 0xe1, 0xc4, 0x73, 0x19, 0x63, 0x3d, +0x4b, 0xdd, 0x4b, 0x4e, 0x44, 0x62, 0x98, 0xc4, 0xf5, 0xd9, 0x50, 0x87, +0x96, 0xb5, 0x72, 0x44, 0x3d, 0x89, 0x58, 0x94, 0x16, 0x8a, 0x1e, 0x0b, +0x0d, 0x4e, 0x0b, 0x04, 0x67, 0x49, 0xda, 0x8b, 0x8a, 0xc4, 0x0a, 0xe1, +0xae, 0x89, 0x8d, 0x88, 0x84, 0x44, 0x4e, 0x86, 0x08, 0x39, 0x9e, 0x55, +0x5b, 0x6d, 0xbc, 0xe7, 0xc8, 0x3d, 0xa4, 0xa4, 0x58, 0xd5, 0x53, 0x87, +0x6d, 0x07, 0xae, 0x78, 0x10, 0x8c, 0xf1, 0x41, 0xbd, 0x89, 0xa0, 0x45, +0xf8, 0x87, 0xfc, 0xeb, 0x08, 0xeb, 0xdf, 0xfd, 0xec, 0x43, 0xa3, 0x72, +0x29, 0xeb, 0x3b, 0x2a, 0x96, 0xd4, 0xee, 0xa8, 0xda, 0xe9, 0x8a, 0x40, +0x70, 0xe0, 0x73, 0x50, 0x6f, 0x42, 0xaf, 0x27, 0x58, 0xfb, 0x33, 0x53, +0xa0, 0xd3, 0xed, 0x1a, 0x78, 0x6a, 0xd2, 0x68, 0xf5, 0x92, 0x7f, 0x70, +0x4c, 0x9e, 0xcc, 0x83, 0xbd, 0x50, 0x52, 0x7b, 0x1e, 0x71, 0xac, 0x53, +0xb9, 0xd4, 0xcf, 0x5a, 0x77, 0x66, 0xde, 0x3c, 0x13, 0x08, 0x0d, 0xb3, +0xf7, 0x3c, 0x46, 0x4e, 0x25, 0xa8, 0x47, 0x78, 0x30, 0x95, 0x23, 0xf9, +0x81, 0xec, 0x37, 0x72, 0x35, 0xde, 0x3e, 0xe5, 0xb0, 0x40, 0xd0, 0xe8, +0xb0, 0xbf, 0x79, 0x73, 0xd4, 0x9b, 0x90, 0x28, 0xc9, 0x2b, 0x81, 0xf0, +0x5e, 0x44, 0x97, 0xe3, 0xe4, 0x94, 0x40, 0x90, 0x7f, 0xa8, 0x6b, 0xe1, +0xcb, 0x29, 0x14, 0x0d, 0xe7, 0x26, 0x0e, 0xe7, 0x73, 0x28, 0xdf, 0x66, +0xce, 0x98, 0xa6, 0xa3, 0x9b, 0x1d, 0x24, 0xbc, 0x40, 0x4c, 0x08, 0xc4, +0x40, 0xb1, 0xb7, 0x56, 0xc3, 0x4f, 0x84, 0x9c, 0xe2, 0x79, 0x10, 0x78, +0xc8, 0xdd, 0xf3, 0xb4, 0x9d, 0xb8, 0x7a, 0x08, 0x6b, 0x7f, 0x47, 0x3b, +0x48, 0x98, 0x5c, 0x6c, 0x7f, 0x95, 0x9c, 0x67, 0x16, 0x14, 0x3d, 0x20, +0xc7, 0xf9, 0x87, 0x7a, 0x85, 0xc2, 0xe5, 0xeb, 0xa3, 0xdf, 0x92, 0x48, +0x9c, 0xb9, 0x72, 0x94, 0x0d, 0xd0, 0x00, 0x61, 0x27, 0xe7, 0xc3, 0xb5, +0x32, 0x3e, 0x64, 0x5d, 0x13, 0x61, 0x10, 0x01, 0xd8, 0xf2, 0x1e, 0xc2, +0xce, 0xd5, 0xdd, 0x46, 0x52, 0xce, 0x84, 0x26, 0x10, 0x88, 0xf6, 0x06, +0x3e, 0x22, 0x71, 0x4e, 0x20, 0xf0, 0x20, 0xc6, 0x0b, 0x3d, 0xc9, 0x62, +0x2f, 0xef, 0x3d, 0x14, 0x06, 0x19, 0x3b, 0x7a, 0x48, 0x6e, 0xa5, 0x73, +0x75, 0x9f, 0x9c, 0x59, 0x3c, 0xb4, 0xc4, 0xd5, 0x3f, 0x40, 0x0e, 0xc8, +0x35, 0x32, 0xf0, 0x13, 0x87, 0x9f, 0x5a, 0xd8, 0x28, 0x1c, 0x16, 0x08, +0x0e, 0xc8, 0x0d, 0xef, 0x89, 0xcb, 0xb8, 0x9e, 0xd4, 0xbb, 0xd0, 0x8a, +0x26, 0x31, 0xd3, 0x3e, 0xbf, 0xdb, 0x35, 0xf0, 0x8c, 0xcb, 0xfd, 0x5e, +0xe2, 0xca, 0x09, 0xea, 0x36, 0x07, 0x7d, 0x0a, 0xa1, 0x68, 0xa4, 0x4f, +0xd1, 0xed, 0x64, 0xd8, 0x8d, 0x30, 0x13, 0x7c, 0x10, 0x0c, 0x37, 0x48, +0x65, 0xdb, 0x25, 0x81, 0xc0, 0x83, 0x68, 0x9a, 0xe8, 0xa1, 0xa7, 0x06, +0x5c, 0xed, 0xdb, 0x85, 0xbc, 0xcc, 0xc4, 0x90, 0x81, 0xd1, 0xb8, 0x9d, +0xed, 0xe2, 0x2a, 0x71, 0x38, 0xd3, 0xb0, 0x0a, 0x1a, 0x16, 0x8a, 0x58, +0xc9, 0xec, 0x06, 0xce, 0x0c, 0xdc, 0x22, 0x08, 0x20, 0x42, 0x01, 0xc3, +0x30, 0x5d, 0x99, 0x30, 0xe2, 0x49, 0x74, 0x9f, 0xa4, 0x19, 0xc4, 0x75, +0x8e, 0x18, 0x76, 0xaa, 0xb9, 0x9a, 0xe3, 0x16, 0x49, 0x0c, 0xb9, 0x31, +0x11, 0x10, 0x08, 0xbb, 0x33, 0xdc, 0x9a, 0x58, 0x52, 0xc9, 0x44, 0x3f, +0x26, 0xbc, 0x09, 0xd7, 0x46, 0x98, 0xe9, 0x92, 0x07, 0xe1, 0x3e, 0x1f, +0xa0, 0x43, 0x24, 0xa0, 0xef, 0x9d, 0xa3, 0x3b, 0x70, 0xdc, 0x7c, 0x6b, +0xf1, 0x90, 0x5c, 0x04, 0x2d, 0x09, 0xfa, 0xd9, 0x34, 0x5c, 0xc9, 0x4d, +0xd4, 0x2e, 0x10, 0x91, 0xcf, 0x86, 0xd0, 0x45, 0x00, 0xba, 0x66, 0xf7, +0x84, 0x11, 0x11, 0xf0, 0x27, 0xa7, 0x37, 0xfb, 0xa5, 0xd3, 0x96, 0xa0, +0x9f, 0x71, 0xe1, 0xce, 0xb7, 0x49, 0x9e, 0x7b, 0x18, 0xef, 0xce, 0x71, +0xc3, 0x1c, 0xc0, 0xa1, 0x73, 0x10, 0x92, 0x94, 0xde, 0xea, 0x49, 0x62, +0x7e, 0x9f, 0x5d, 0x55, 0x47, 0x1e, 0xe6, 0x91, 0xf1, 0xd1, 0xc2, 0x06, +0x21, 0xc1, 0xa1, 0xc1, 0x89, 0x61, 0x02, 0xdd, 0x72, 0x24, 0x39, 0xa9, +0x49, 0xe9, 0x35, 0x81, 0xd0, 0xdf, 0xc7, 0x8b, 0xe8, 0x92, 0xa7, 0xb7, +0xdb, 0x99, 0xfb, 0xac, 0x5b, 0xd8, 0x4d, 0x5f, 0xba, 0x97, 0x1a, 0x0f, +0x02, 0x46, 0x63, 0x77, 0x87, 0x4b, 0x3d, 0x66, 0xbe, 0x26, 0x10, 0xc1, +0xef, 0xb3, 0xab, 0xea, 0x74, 0x33, 0x61, 0x43, 0x34, 0x46, 0x18, 0x5a, +0xca, 0x3d, 0x9d, 0xba, 0x20, 0xcb, 0xd1, 0x86, 0x03, 0xf0, 0x22, 0x5e, +0xef, 0x98, 0xa4, 0x79, 0x55, 0x18, 0xc7, 0x15, 0x81, 0x90, 0xdf, 0x77, +0x24, 0xef, 0x46, 0xe0, 0xe6, 0x37, 0x15, 0x53, 0xa3, 0xbb, 0xe7, 0x7b, +0xc4, 0x3c, 0x04, 0x1b, 0x21, 0x18, 0x82, 0x5d, 0x93, 0x46, 0x2f, 0xea, +0x0e, 0xff, 0xae, 0x84, 0x97, 0x10, 0x08, 0x68, 0x65, 0xac, 0xc7, 0xc8, +0x43, 0x10, 0x4a, 0x85, 0xd1, 0x78, 0x79, 0x1d, 0xdf, 0x56, 0x88, 0x49, +0xc4, 0xc1, 0xe6, 0x26, 0x70, 0xbd, 0xa1, 0x01, 0x2f, 0xe8, 0xea, 0x65, +0xf6, 0x78, 0x0f, 0x80, 0x48, 0xb8, 0x17, 0x77, 0xb3, 0x6a, 0x82, 0x3a, +0xf8, 0x77, 0x4c, 0x1e, 0x68, 0xc2, 0x9b, 0x70, 0x07, 0x7b, 0x52, 0xf9, +0x71, 0xce, 0xf8, 0x86, 0x71, 0x27, 0x4d, 0x98, 0x8c, 0x74, 0xfd, 0x5f, +0x45, 0x09, 0xa0, 0x9d, 0x3a, 0x17, 0x6d, 0xed, 0xbc, 0x32, 0xb6, 0x17, +0xc7, 0x61, 0x50, 0x80, 0x77, 0x37, 0xdc, 0xb6, 0xb7, 0x9d, 0x75, 0xf2, +0x84, 0x13, 0xc8, 0xef, 0xc0, 0x98, 0x3c, 0xd0, 0xdb, 0xf8, 0x0f, 0x0d, +0x00, 0x4e, 0x4c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbd, 0xdc, 0xbf, 0x7e, 0xfd, +0xfa, 0x1f, 0x1e, 0x03, 0x00, 0x00, 0x84, 0x2c, 0x7f, 0xec, 0x4d, 0x84, +0x82, 0x47, 0x01, 0x00, 0x00, 0xef, 0xde, 0xc3, 0xb7, 0x6f, 0xdf, 0xfe, +0xe7, 0x05, 0x62, 0xe2, 0x71, 0x00, 0x00, 0x40, 0xe8, 0x3d, 0xbc, 0xf9, +0xff, 0x06, 0x00, 0x00, 0x78, 0x84, 0x94, 0xde, 0x8c, 0xcd, 0x3c, 0x12, +0x00, 0x00, 0xb8, 0x7d, 0xf9, 0xf2, 0xe5, 0xbf, 0x81, 0x40, 0xe0, 0x41, +0x00, 0x00, 0x8c, 0x8e, 0xaf, 0x5a, 0xb2, 0xe2, 0xf0, 0x46, 0x25, 0x13, +0x00, 0xc0, 0xe0, 0x9e, 0xc3, 0x9a, 0x38, 0x20, 0x10, 0x00, 0x00, 0x78, +0x0e, 0xab, 0xe2, 0x80, 0x40, 0x00, 0x00, 0x20, 0x0e, 0x6f, 0x08, 0x04, +0x00, 0x00, 0xec, 0x16, 0x07, 0x04, 0x02, 0x00, 0x00, 0x71, 0x40, 0x20, +0x00, 0x00, 0x60, 0xbf, 0x38, 0x20, 0x10, 0x00, 0x00, 0x63, 0xb1, 0xec, +0x15, 0x87, 0x84, 0x02, 0x71, 0xe3, 0x35, 0x00, 0x00, 0x34, 0x2c, 0x0e, +0x2e, 0xdd, 0x41, 0xb9, 0x89, 0x57, 0x01, 0x00, 0x50, 0x07, 0xb7, 0x23, +0x61, 0x25, 0x97, 0xae, 0xd5, 0x86, 0xb6, 0x10, 0xa7, 0x7d, 0x07, 0x00, +0x40, 0x05, 0xdc, 0x57, 0xda, 0x67, 0x1c, 0xb1, 0xab, 0xed, 0xbe, 0x25, +0x9c, 0x34, 0x8b, 0x30, 0x98, 0x0e, 0xb1, 0xb4, 0x10, 0x07, 0x00, 0x28, +0xcc, 0x6c, 0x16, 0xe5, 0xc3, 0xe6, 0xff, 0xed, 0x29, 0x51, 0x5a, 0x11, +0x05, 0xfb, 0x35, 0xc9, 0x41, 0x00, 0x00, 0x14, 0x42, 0x16, 0xe0, 0x33, +0xf9, 0x86, 0x0f, 0xe6, 0x3d, 0x8f, 0x43, 0xa2, 0xf0, 0xca, 0x5b, 0x39, +0xf8, 0x35, 0x01, 0x00, 0x20, 0x26, 0x6b, 0x3b, 0xf7, 0x93, 0xb6, 0x27, +0x41, 0x7d, 0x3f, 0x98, 0xdf, 0x20, 0xff, 0x00, 0x00, 0x50, 0x4a, 0x1c, +0x7e, 0xfc, 0xf8, 0xf1, 0xcf, 0xf7, 0xef, 0xdf, 0xff, 0xb9, 0x22, 0x0e, +0x22, 0x30, 0xf2, 0x75, 0xbc, 0x48, 0xdc, 0x22, 0x7a, 0x29, 0xe4, 0x1f, +0x00, 0x00, 0x4a, 0x88, 0xc3, 0xb2, 0x2c, 0x6f, 0x7e, 0x61, 0xbf, 0xe4, +0x3d, 0xc8, 0xd7, 0xf9, 0xfd, 0xfb, 0xf7, 0xdb, 0xaf, 0x5f, 0xbf, 0xde, +0xbc, 0xd8, 0x2c, 0x46, 0x18, 0x4e, 0xe5, 0x36, 0x2e, 0xe4, 0x34, 0x00, +0x00, 0xe0, 0x24, 0x8f, 0x32, 0xd6, 0x9f, 0x3f, 0x7f, 0xbe, 0x89, 0x5d, +0x15, 0x07, 0x59, 0xc8, 0xe5, 0xeb, 0x88, 0x38, 0x88, 0x48, 0x88, 0x89, +0x60, 0xc8, 0xf7, 0xb8, 0x58, 0x11, 0xc5, 0xe5, 0x43, 0x00, 0x00, 0x25, +0x3c, 0x07, 0x59, 0xd0, 0x23, 0xe5, 0x1e, 0xde, 0x85, 0x42, 0xbc, 0x07, +0xf5, 0x26, 0xc4, 0xce, 0x7a, 0x27, 0x54, 0x2f, 0x01, 0x00, 0x14, 0x12, +0x07, 0x59, 0xbc, 0xaf, 0xe6, 0x1d, 0xf6, 0x78, 0x15, 0xea, 0x4d, 0x1c, +0xfd, 0xf7, 0xf4, 0x74, 0x02, 0x00, 0xc8, 0xcb, 0x2c, 0x3b, 0x7a, 0x59, +0xb4, 0x63, 0x84, 0x96, 0xf6, 0x98, 0x7e, 0xbf, 0x23, 0x22, 0x81, 0xf7, +0x00, 0x00, 0x90, 0x97, 0xbb, 0x2c, 0xbc, 0x12, 0x56, 0x8a, 0x1d, 0x5a, +0xda, 0x2b, 0x12, 0x07, 0xc2, 0x4d, 0x94, 0xb6, 0x02, 0x00, 0xe4, 0x42, +0x92, 0xc5, 0x1a, 0xf2, 0x89, 0x51, 0xb5, 0x94, 0x4a, 0x24, 0x38, 0x18, +0x07, 0x00, 0x90, 0x97, 0xec, 0xa1, 0xa5, 0x2d, 0x91, 0xd8, 0xe1, 0xbd, +0x4c, 0xbc, 0x2e, 0x00, 0x80, 0x3c, 0xbc, 0x87, 0x96, 0x52, 0x27, 0xa6, +0xdd, 0xce, 0xf3, 0x12, 0x4f, 0xf2, 0x11, 0x84, 0x96, 0x00, 0x00, 0x72, +0x51, 0x3a, 0xb4, 0xb4, 0x25, 0x12, 0x56, 0xa8, 0xbc, 0x47, 0x81, 0x38, +0x00, 0x00, 0xe4, 0xc2, 0x96, 0xb4, 0x96, 0x0c, 0x2d, 0xb9, 0xed, 0xb6, +0x1c, 0x9a, 0x73, 0x98, 0x78, 0x5b, 0x00, 0x00, 0xf9, 0x98, 0x65, 0x97, +0xae, 0x07, 0xd6, 0x4a, 0x87, 0x96, 0x1c, 0xe5, 0xac, 0x00, 0x00, 0x55, +0x30, 0x89, 0x20, 0x68, 0xde, 0xe1, 0xcc, 0x41, 0x35, 0x04, 0x02, 0x00, +0xa0, 0x43, 0x71, 0xb0, 0x49, 0xe9, 0x5a, 0xc5, 0xc1, 0xd1, 0x6f, 0x09, +0x00, 0xa0, 0x9c, 0x38, 0xc8, 0xaf, 0x95, 0x8b, 0x03, 0xe7, 0x1e, 0x00, +0x00, 0x32, 0x30, 0xdb, 0xb0, 0x52, 0x4d, 0x79, 0x07, 0xf9, 0x1c, 0x2f, +0x3e, 0xcb, 0xc4, 0xeb, 0x03, 0x00, 0x88, 0xcf, 0xe3, 0x86, 0xb6, 0x50, +0x1c, 0x6a, 0x29, 0x69, 0x15, 0x93, 0x0a, 0xaa, 0x17, 0x9f, 0x87, 0x30, +0x13, 0x00, 0x40, 0x24, 0x24, 0xb1, 0x3b, 0xe9, 0x55, 0xa1, 0xb6, 0xbd, +0x76, 0x2d, 0x79, 0x07, 0xeb, 0x31, 0x88, 0x70, 0x3d, 0xfb, 0x4c, 0x74, +0x6e, 0x05, 0x00, 0x88, 0xe0, 0x2d, 0xc8, 0x6e, 0xdb, 0xde, 0xbb, 0x60, +0xbd, 0x86, 0x1d, 0x3b, 0xf5, 0x6c, 0x1e, 0x83, 0x7c, 0x1e, 0x2b, 0x10, +0xcf, 0xf2, 0x21, 0xe4, 0x21, 0x00, 0x00, 0x2e, 0x08, 0x83, 0x7a, 0x0b, +0x1a, 0xcf, 0x17, 0x21, 0xd0, 0xbb, 0xa4, 0xc5, 0x72, 0x76, 0x67, 0xdd, +0x23, 0x0e, 0x62, 0xfa, 0x99, 0x76, 0xb6, 0xf9, 0x98, 0x78, 0xcd, 0x00, +0x00, 0xfb, 0xb9, 0xa9, 0x30, 0xb8, 0xca, 0xab, 0x91, 0x9c, 0xe9, 0xd8, +0x6a, 0x05, 0x42, 0x6c, 0x4f, 0x5e, 0x84, 0x30, 0x13, 0x00, 0xc0, 0x7e, +0xa6, 0x8b, 0xf7, 0x39, 0x67, 0x17, 0x07, 0x1b, 0xf2, 0xd2, 0x90, 0xd2, +0x5e, 0x81, 0xf0, 0x22, 0x08, 0x00, 0x00, 0x4f, 0x98, 0x5b, 0x12, 0x06, +0xe7, 0x13, 0xd2, 0x9a, 0x03, 0xd1, 0xdc, 0x88, 0x86, 0x93, 0x6c, 0xbb, +0x8f, 0x1d, 0xc9, 0xf3, 0x89, 0xd7, 0x0f, 0x00, 0xf0, 0x91, 0x5b, 0x8b, +0xc2, 0xe0, 0x56, 0xc2, 0x4a, 0x61, 0x9e, 0xc1, 0xfe, 0xf9, 0x8e, 0x86, +0x81, 0x94, 0xbb, 0x02, 0x00, 0x18, 0x61, 0x58, 0x44, 0x18, 0x34, 0xe1, +0xdc, 0x9a, 0x40, 0x84, 0x25, 0xb6, 0x61, 0xb5, 0xd2, 0x11, 0x81, 0x20, +0x0f, 0x01, 0x00, 0xf0, 0x6f, 0x28, 0xe5, 0x21, 0x0c, 0x7a, 0x81, 0x4e, +0x8b, 0xe2, 0xb0, 0x26, 0x10, 0x2a, 0x04, 0x9a, 0x58, 0x3f, 0x22, 0x10, +0xfe, 0xdf, 0xdc, 0x19, 0x1e, 0x00, 0x30, 0x8a, 0x87, 0x20, 0x62, 0x30, +0x7b, 0x7b, 0xf7, 0x16, 0x6a, 0xbc, 0xa7, 0xe1, 0x8a, 0x48, 0xd8, 0xf3, +0x18, 0xea, 0x49, 0x9c, 0x39, 0xc0, 0x87, 0x17, 0x01, 0x90, 0x77, 0x81, +0xd2, 0x45, 0xca, 0x2e, 0x54, 0xa1, 0x4d, 0x8e, 0xb6, 0xcb, 0xb1, 0xb8, +0x5b, 0x0f, 0xc1, 0x9e, 0x59, 0x10, 0x31, 0xb0, 0x0b, 0x69, 0x03, 0x9d, +0x56, 0x0f, 0x27, 0xab, 0xe5, 0x67, 0x92, 0x9f, 0x33, 0xb4, 0x83, 0x07, +0xf8, 0xc8, 0x45, 0x00, 0xbc, 0x58, 0xd4, 0xef, 0x66, 0x61, 0xff, 0xb0, +0x0b, 0x55, 0x93, 0xdd, 0xd6, 0x96, 0xc9, 0xe2, 0xa4, 0x75, 0xe8, 0x6e, +0x67, 0x6f, 0x7e, 0x31, 0xbf, 0x83, 0xd3, 0xef, 0xb1, 0x26, 0x24, 0xd3, +0xa0, 0x82, 0x12, 0xbe, 0x93, 0xf7, 0xf7, 0x61, 0x9f, 0xb9, 0x0a, 0xc2, +0xda, 0xae, 0xda, 0x5a, 0x4d, 0xbd, 0x92, 0x5c, 0xbd, 0x6d, 0xc0, 0xd9, +0xb4, 0x00, 0x21, 0x08, 0x1b, 0x7e, 0x38, 0xb2, 0xa8, 0xbb, 0xc2, 0x97, +0xbd, 0x78, 0x31, 0x09, 0x85, 0xe3, 0xde, 0xc1, 0xc4, 0x7e, 0x7f, 0x2f, +0x7a, 0x50, 0xed, 0xd9, 0x3b, 0xb1, 0xa7, 0x9b, 0xc3, 0x1d, 0xb4, 0xe6, +0x18, 0xac, 0xb5, 0x9a, 0x6f, 0x70, 0x65, 0x5a, 0x81, 0x93, 0x93, 0x80, +0xa1, 0x76, 0xa0, 0xb3, 0xdd, 0xe1, 0xf7, 0x36, 0xa9, 0x75, 0x31, 0x55, +0x01, 0x31, 0x1e, 0xc9, 0xbc, 0xb2, 0xfb, 0x9e, 0x8c, 0xc7, 0x74, 0xcb, +0xf0, 0xec, 0x43, 0x9b, 0x42, 0xaf, 0xac, 0xd7, 0xf7, 0xd2, 0xf2, 0x78, +0x42, 0x24, 0xa0, 0xeb, 0x90, 0x44, 0x4b, 0xed, 0x12, 0x4a, 0x0a, 0x8a, +0x2c, 0xce, 0x41, 0x88, 0xeb, 0x92, 0x9d, 0x09, 0xb5, 0x61, 0xd5, 0xda, +0xcc, 0x92, 0x02, 0x2d, 0x87, 0x23, 0x3e, 0x2d, 0x4a, 0x4c, 0x6a, 0x0c, +0xe3, 0xfe, 0x6a, 0x18, 0xd0, 0x2b, 0x20, 0x1c, 0x81, 0x61, 0xd9, 0x05, +0x02, 0xa0, 0x4e, 0x0f, 0x61, 0x4f, 0xb2, 0x12, 0xc3, 0x30, 0x3c, 0x08, +0xe8, 0x1f, 0x3c, 0x04, 0x0c, 0xab, 0xcf, 0x26, 0x96, 0x26, 0xc8, 0xcd, +0xa3, 0xb2, 0xc8, 0xe6, 0x0f, 0x98, 0x88, 0x18, 0x86, 0x40, 0xc0, 0x98, +0xf9, 0x83, 0x99, 0x44, 0x32, 0x86, 0x11, 0x62, 0x82, 0x41, 0x43, 0x43, +0xee, 0x6f, 0x8d, 0xfd, 0x4c, 0xa8, 0x08, 0xc3, 0xba, 0x39, 0x59, 0x0d, +0x70, 0x3e, 0x5f, 0xa0, 0x77, 0xf3, 0x12, 0x26, 0xc2, 0xb0, 0xee, 0x8c, +0xc3, 0x72, 0x70, 0x88, 0xd9, 0x1f, 0xaa, 0x62, 0xf2, 0x60, 0x18, 0x87, +0xe4, 0x00, 0x1e, 0xbb, 0x88, 0x05, 0x0f, 0x01, 0xc3, 0x86, 0xea, 0xc7, +0x04, 0xb0, 0x29, 0x08, 0x13, 0xa2, 0x80, 0x61, 0x54, 0x2e, 0x01, 0x08, +0xcd, 0xde, 0xcf, 0x8b, 0x61, 0x58, 0x3c, 0xe3, 0xf2, 0x20, 0xf8, 0x14, +0x3e, 0xa2, 0xda, 0x08, 0xc3, 0x30, 0xca, 0x5a, 0x41, 0x45, 0x61, 0xa6, +0xdb, 0x29, 0x86, 0x61, 0x84, 0x96, 0x00, 0x6f, 0x01, 0xc3, 0x30, 0xce, +0x3c, 0xc0, 0xba, 0x30, 0xc4, 0x2a, 0x4d, 0x45, 0x5c, 0x30, 0x8c, 0xbc, +0x03, 0x90, 0x74, 0xfe, 0x64, 0x72, 0xb5, 0x23, 0xd7, 0x36, 0x62, 0x58, +0x77, 0x39, 0x07, 0x3c, 0x87, 0x81, 0x88, 0x7e, 0x93, 0x9a, 0x88, 0x02, +0x77, 0xfa, 0x62, 0x58, 0x5f, 0xc2, 0xe0, 0xbd, 0x06, 0x4e, 0x4a, 0xe3, +0x2d, 0x5c, 0x13, 0x87, 0x5f, 0xbf, 0x7e, 0x21, 0x0e, 0x18, 0xd6, 0x8f, +0x28, 0x4c, 0x8e, 0x4a, 0xa5, 0x71, 0x72, 0x0b, 0xa9, 0xf2, 0x02, 0x12, +0x52, 0xfa, 0xfd, 0xfb, 0xf7, 0xe3, 0x57, 0x26, 0x18, 0x86, 0x95, 0x5b, +0xd8, 0x9f, 0x99, 0x6c, 0x0c, 0xd5, 0xdc, 0xc7, 0xfb, 0xc1, 0xb5, 0x79, +0xe6, 0x84, 0xa7, 0x40, 0x18, 0x29, 0x89, 0x38, 0xfc, 0xfc, 0xf9, 0x93, +0x49, 0x8a, 0x61, 0x65, 0x5a, 0x5d, 0xe8, 0xc2, 0x7e, 0x7b, 0x61, 0x00, +0xf9, 0xfa, 0x21, 0x49, 0xbe, 0x41, 0xc4, 0x41, 0x8c, 0xd0, 0x12, 0x86, +0xd1, 0x07, 0x09, 0xea, 0x25, 0x6b, 0xf7, 0x54, 0xc4, 0x01, 0xc3, 0x28, +0x39, 0x85, 0x06, 0x84, 0x21, 0x77, 0x5f, 0x24, 0x09, 0x27, 0xa9, 0x38, +0x90, 0x77, 0xc0, 0x30, 0x0e, 0xac, 0x41, 0x5d, 0x14, 0x69, 0x98, 0x27, +0x9e, 0x02, 0xe2, 0x80, 0x61, 0xb4, 0xbb, 0x80, 0x4a, 0x45, 0xc1, 0x15, +0x6c, 0xad, 0x6d, 0xc3, 0x4a, 0x88, 0x03, 0x86, 0x15, 0x37, 0x2a, 0x8e, +0xe0, 0xdf, 0xfb, 0x16, 0x4a, 0xb7, 0xae, 0x90, 0xef, 0xaf, 0xde, 0x83, +0x08, 0x05, 0x93, 0x13, 0xc3, 0xe8, 0xa6, 0x0a, 0x83, 0x24, 0x9d, 0xdd, +0x8b, 0x52, 0x56, 0x39, 0x04, 0x47, 0x39, 0x2b, 0x86, 0x51, 0xc1, 0x04, +0xe5, 0x59, 0x6a, 0xa8, 0x0c, 0xb2, 0x5e, 0x83, 0x98, 0x88, 0x04, 0x4d, +0xf8, 0x30, 0x8c, 0x04, 0x35, 0xe4, 0xe7, 0x5e, 0x83, 0xd7, 0xa0, 0x27, +0x2d, 0xb5, 0x75, 0x86, 0x8a, 0x03, 0xe5, 0xac, 0x18, 0x46, 0xfe, 0x01, +0xf2, 0x27, 0x9e, 0xa7, 0x1a, 0x2e, 0xe4, 0x31, 0xdd, 0x1a, 0xef, 0x22, +0x10, 0xd6, 0x73, 0x20, 0xef, 0x80, 0x61, 0xd5, 0xe5, 0x1f, 0xa0, 0x73, +0x61, 0x98, 0x6b, 0x08, 0xd7, 0x98, 0xa3, 0xfa, 0x0f, 0x44, 0xac, 0x6c, +0xb5, 0x12, 0xe2, 0x80, 0x61, 0xe4, 0x1f, 0x60, 0x30, 0x6f, 0x61, 0xa5, +0x85, 0xef, 0x4d, 0x06, 0x9e, 0xf6, 0x56, 0xd2, 0x9c, 0x03, 0x61, 0x25, +0x0c, 0xab, 0xce, 0x66, 0x96, 0xd3, 0x7e, 0x98, 0x6a, 0xb9, 0xd3, 0xd9, +0x84, 0x91, 0x3e, 0x95, 0xc7, 0xc9, 0x9f, 0x59, 0xcf, 0x81, 0x84, 0x34, +0x86, 0x55, 0x1b, 0x5e, 0x22, 0xff, 0xd0, 0x7a, 0xc2, 0x59, 0x44, 0xa1, +0xd4, 0x81, 0xb6, 0x8d, 0x41, 0x35, 0xbb, 0xed, 0xba, 0xe9, 0x25, 0xf4, +0x1c, 0x10, 0x07, 0x0c, 0x23, 0xbc, 0x04, 0x91, 0x3d, 0x85, 0x5a, 0x44, +0xc1, 0x0c, 0xa6, 0x67, 0xc2, 0xf0, 0xf8, 0xdc, 0x22, 0x06, 0x54, 0x2b, +0x61, 0x18, 0x0d, 0xfa, 0xa0, 0xd3, 0xf0, 0xd1, 0xb3, 0xc4, 0xf3, 0xb3, +0xbc, 0x48, 0x78, 0xd6, 0x81, 0x16, 0x1a, 0x18, 0x46, 0x79, 0x2b, 0x9c, +0x08, 0x1b, 0x39, 0xd3, 0x0b, 0xa9, 0x26, 0x51, 0xd0, 0xcf, 0x72, 0x40, +0x18, 0x1e, 0xc8, 0xdf, 0xb7, 0x79, 0x07, 0xaa, 0x95, 0xb0, 0x1e, 0x63, +0xf6, 0xbd, 0x84, 0x4b, 0x09, 0x2f, 0xd5, 0xc3, 0xcd, 0x2f, 0xb4, 0x4b, +0x6d, 0x61, 0x23, 0x67, 0x3a, 0xab, 0x8a, 0x99, 0x8a, 0xa4, 0xa3, 0x95, +0x0d, 0x8f, 0xd3, 0xda, 0x88, 0x03, 0xd6, 0xbb, 0x40, 0x74, 0x34, 0xb6, +0x39, 0x3d, 0x5d, 0x50, 0x10, 0x66, 0x15, 0x84, 0x5a, 0x77, 0x1c, 0x2a, +0x0a, 0x3e, 0x0c, 0xa4, 0x77, 0xc9, 0x9e, 0x71, 0x39, 0x67, 0x2b, 0x0e, +0xf4, 0x57, 0xc2, 0x7a, 0x36, 0x99, 0x2f, 0xad, 0x8b, 0x04, 0xd5, 0x4b, +0xf9, 0x43, 0x45, 0xd5, 0x0b, 0x82, 0x1d, 0x1c, 0xb2, 0xa0, 0x1b, 0x4f, +0xe1, 0xca, 0x40, 0x59, 0x6c, 0x1b, 0x0d, 0x2a, 0x96, 0xb0, 0x11, 0x4c, +0x36, 0x41, 0xb5, 0x14, 0x5f, 0x9c, 0xf9, 0x1c, 0x24, 0xa7, 0x33, 0x24, +0x94, 0x5d, 0xc1, 0xbb, 0x14, 0x22, 0x54, 0x2e, 0x4c, 0x11, 0x9e, 0xc1, +0x87, 0xb0, 0x12, 0x49, 0x69, 0x6c, 0x14, 0xd3, 0xcb, 0xae, 0x6a, 0xd9, +0xec, 0xe1, 0x3d, 0xd4, 0xc5, 0xd2, 0x9a, 0x3b, 0xe9, 0x45, 0x61, 0x71, +0xf1, 0x6e, 0x8d, 0x9a, 0xc3, 0x06, 0x7c, 0x84, 0x96, 0xb0, 0x91, 0x4c, +0xc2, 0x4c, 0xa5, 0xbd, 0x88, 0x33, 0x02, 0x81, 0xf7, 0x90, 0x3e, 0xa4, +0xd4, 0x52, 0x95, 0xc2, 0x92, 0x60, 0xb7, 0x30, 0x85, 0xe2, 0x40, 0x68, +0x09, 0xc3, 0x8b, 0x28, 0xf3, 0x19, 0x8e, 0x78, 0xed, 0x7e, 0x8e, 0x4e, +0x2c, 0xe3, 0xe9, 0x98, 0x1b, 0xf0, 0x14, 0x66, 0x97, 0xce, 0x85, 0x5c, +0xed, 0xce, 0xca, 0x61, 0x38, 0x8c, 0x5c, 0x44, 0x19, 0x81, 0x38, 0x92, +0x30, 0xa7, 0xb4, 0x35, 0x83, 0x07, 0x51, 0xdb, 0x4e, 0xd9, 0xb6, 0xd6, +0x4e, 0xfc, 0xb3, 0xdf, 0xd6, 0xba, 0xb3, 0x12, 0x5a, 0xc2, 0x46, 0x35, +0xd9, 0xbd, 0x97, 0xcc, 0xbb, 0x9d, 0xa8, 0xa8, 0xa2, 0xb4, 0x35, 0x47, +0x82, 0xba, 0xa2, 0xd6, 0xda, 0xaf, 0x5a, 0x5f, 0x44, 0x43, 0xc4, 0xc1, +0xf6, 0x58, 0x22, 0xb4, 0x84, 0x11, 0x66, 0x2a, 0x1b, 0x66, 0x3a, 0x22, +0x10, 0x7e, 0xbd, 0xe0, 0xde, 0xe9, 0x5c, 0x9e, 0x44, 0xee, 0xdb, 0xda, +0x64, 0x21, 0x4e, 0x98, 0x57, 0x78, 0x99, 0x98, 0x0f, 0xc5, 0x81, 0xaa, +0x25, 0x0c, 0xfb, 0x77, 0x91, 0x2e, 0xb5, 0x49, 0x3a, 0xe8, 0x41, 0x90, +0x7b, 0x28, 0x94, 0xb4, 0x8e, 0x5a, 0xee, 0xaa, 0x42, 0x60, 0x2a, 0x8f, +0x34, 0xa7, 0x50, 0x4a, 0xfd, 0xe7, 0xb0, 0x9c, 0x95, 0xd0, 0x12, 0x86, +0x7d, 0x3c, 0x70, 0x5a, 0x4a, 0x20, 0xc4, 0x8b, 0x27, 0xb4, 0xd4, 0x8e, +0x58, 0x4c, 0xfe, 0x65, 0xbc, 0xb7, 0xd5, 0x78, 0x65, 0x15, 0x09, 0xc1, +0x6a, 0xde, 0x41, 0x04, 0x2b, 0xbc, 0x4f, 0x9a, 0xd0, 0x12, 0x86, 0xfd, +0xdd, 0xd0, 0x95, 0xf2, 0xa4, 0xe5, 0xfb, 0xbe, 0xda, 0xa8, 0x11, 0x5a, +0x82, 0xa4, 0x79, 0x87, 0x30, 0x29, 0x4d, 0x68, 0x09, 0xc3, 0xae, 0x9f, +0x66, 0xce, 0x21, 0x10, 0x1c, 0x8a, 0x83, 0xec, 0xa1, 0x25, 0xc4, 0x01, +0xc3, 0xea, 0xe8, 0xf2, 0xaa, 0x79, 0xc1, 0x35, 0x81, 0x42, 0x1c, 0x20, +0x25, 0xd3, 0x5a, 0x68, 0x89, 0xbc, 0x03, 0x86, 0xd5, 0x27, 0x10, 0x1b, +0x9b, 0x36, 0x92, 0xd2, 0x90, 0x4f, 0x1c, 0x24, 0xd4, 0x44, 0xde, 0x01, +0xc3, 0x9e, 0x86, 0x73, 0xb2, 0x1f, 0xd4, 0xd3, 0x9c, 0x60, 0xf0, 0x67, +0x33, 0xcb, 0x18, 0xa4, 0xe0, 0x1e, 0xde, 0x0a, 0xc7, 0xfd, 0x0e, 0x18, +0x56, 0x67, 0x1e, 0xc2, 0x6e, 0xe2, 0xf4, 0xfb, 0x73, 0x5a, 0x1a, 0x92, +0xe5, 0x1c, 0xd6, 0xc4, 0x81, 0x9c, 0x43, 0x5d, 0xbb, 0x46, 0x0c, 0x5b, +0x13, 0x08, 0x13, 0xfe, 0x25, 0xef, 0x00, 0x71, 0xbd, 0x06, 0x3d, 0xf4, +0x67, 0x0f, 0xc3, 0xc9, 0xe0, 0x43, 0x1c, 0x3e, 0x1e, 0x48, 0x92, 0x49, +0x58, 0x43, 0x17, 0x4f, 0x0c, 0x0b, 0xe7, 0xab, 0xf1, 0x22, 0xc8, 0x3d, +0x40, 0x5c, 0xaf, 0xc1, 0x99, 0x43, 0x37, 0xba, 0x1b, 0x19, 0x7d, 0x77, +0xac, 0x8d, 0xd0, 0xe4, 0x59, 0xc8, 0x73, 0x91, 0xff, 0x96, 0x67, 0x84, +0x38, 0x60, 0x35, 0x99, 0x2d, 0x43, 0x97, 0xb1, 0x4a, 0x88, 0x09, 0xae, +0xf0, 0x7e, 0x3f, 0xb6, 0x0c, 0x24, 0xbb, 0x08, 0x92, 0x6f, 0xf8, 0xdb, +0x3e, 0xd9, 0x8a, 0x82, 0xbd, 0x9a, 0x15, 0x71, 0xc0, 0x6a, 0x34, 0x3b, +0x7f, 0xcd, 0x15, 0xc2, 0x00, 0xaf, 0xc3, 0x47, 0xce, 0x5f, 0x89, 0xaa, +0xd7, 0xa1, 0xea, 0xc9, 0xcf, 0x30, 0xd7, 0x30, 0x6a, 0x48, 0x29, 0xf4, +0x14, 0xac, 0x30, 0xc8, 0xaf, 0xe1, 0xbd, 0x17, 0xf2, 0xf7, 0x34, 0xd4, +0xa4, 0xdd, 0x3c, 0x11, 0x0e, 0xac, 0x16, 0x91, 0xd0, 0x2e, 0x07, 0x5c, +0x0c, 0x04, 0x4f, 0x45, 0x41, 0x3d, 0x04, 0x5d, 0xc4, 0xec, 0x02, 0x18, +0x1e, 0x7e, 0x1b, 0xcd, 0x6b, 0xb0, 0x9e, 0x82, 0x15, 0x47, 0xbb, 0xd0, +0xdb, 0x67, 0x16, 0x3e, 0xaf, 0x35, 0xb3, 0xa2, 0x81, 0x60, 0xc4, 0x39, +0x57, 0xa0, 0x37, 0xa6, 0xd9, 0x71, 0x7c, 0xd6, 0xf4, 0xeb, 0x6c, 0x99, +0xfd, 0x9e, 0xad, 0x86, 0x57, 0x75, 0x3c, 0x9b, 0x10, 0x31, 0x09, 0x6b, +0xf8, 0x10, 0x3e, 0x9a, 0xb7, 0x3c, 0x84, 0xad, 0x45, 0x6d, 0x84, 0xc5, +0x4c, 0x17, 0x1a, 0x9b, 0x67, 0x51, 0x61, 0x78, 0x75, 0xbe, 0x43, 0x2b, +0xbb, 0x54, 0x5c, 0x8f, 0x0a, 0x86, 0x5d, 0x80, 0x46, 0x5d, 0xec, 0xd7, +0x16, 0x64, 0x4d, 0xfc, 0x5b, 0x0b, 0x9f, 0xf3, 0xde, 0x67, 0x9d, 0xc2, +0xf4, 0xfb, 0xaf, 0x79, 0x8b, 0x35, 0xbf, 0x53, 0xcd, 0x49, 0x20, 0x12, +0x60, 0x85, 0x61, 0x51, 0x61, 0xd8, 0x33, 0xa9, 0x64, 0xf0, 0xf4, 0x1e, +0x4e, 0x5a, 0xcb, 0xaf, 0x58, 0x51, 0x38, 0x2b, 0x8c, 0x56, 0x6c, 0xd6, +0x16, 0xb5, 0x57, 0x8b, 0x4e, 0x28, 0x1c, 0x2d, 0x3f, 0xdf, 0xad, 0x45, +0x5f, 0xc3, 0x70, 0xa5, 0x17, 0xf9, 0x70, 0xb1, 0x0f, 0x17, 0x7d, 0xbb, +0xf0, 0x6f, 0x09, 0x96, 0x0d, 0x29, 0xea, 0xcf, 0x64, 0x7f, 0xb5, 0x7f, +0xbf, 0xa6, 0x77, 0xa3, 0x9f, 0x0f, 0x91, 0x40, 0x18, 0x36, 0x85, 0x61, +0x6d, 0x52, 0xf4, 0xe8, 0x31, 0xd8, 0x45, 0x7b, 0x2b, 0x2c, 0x94, 0xcb, +0x5b, 0xb2, 0xa1, 0x91, 0x70, 0xd1, 0x59, 0xf3, 0xea, 0xc2, 0x5d, 0x6a, +0xe9, 0x1d, 0x6a, 0x18, 0xda, 0xb1, 0x42, 0x6b, 0x17, 0xfe, 0x1a, 0x16, +0xfb, 0x70, 0x81, 0xb6, 0xbb, 0x7c, 0xfd, 0xf5, 0x48, 0xc8, 0x48, 0x5b, +0xed, 0xaf, 0x74, 0x5a, 0x7e, 0xb7, 0xb0, 0x4b, 0x73, 0xad, 0x45, 0x0c, +0xea, 0xf9, 0x9a, 0x71, 0x3f, 0xb1, 0x64, 0x0e, 0x94, 0x67, 0x90, 0xc1, +0xb9, 0x26, 0x0c, 0x76, 0x87, 0xdc, 0x73, 0x58, 0x43, 0x17, 0xb1, 0xb5, +0x6e, 0xb3, 0x76, 0xe1, 0x2d, 0x79, 0xa1, 0xcb, 0xb3, 0xfc, 0x87, 0xdd, +0xb5, 0xea, 0x3b, 0x0c, 0x77, 0xba, 0x36, 0x69, 0x6e, 0xc5, 0x23, 0x8c, +0x97, 0x87, 0xf6, 0x2a, 0xde, 0xbe, 0x25, 0x5e, 0xb5, 0x87, 0x76, 0x62, +0xbf, 0xc7, 0xe0, 0x12, 0xae, 0xc9, 0x1d, 0x6f, 0x8b, 0x7d, 0xf3, 0x76, +0xd7, 0x42, 0x10, 0x17, 0xb4, 0xda, 0x2e, 0x3d, 0xf6, 0x74, 0xd3, 0x84, +0x48, 0x8c, 0xc3, 0x14, 0x9e, 0x78, 0xd6, 0x85, 0xb0, 0xe7, 0x7c, 0x82, +0x7a, 0x4a, 0x61, 0x65, 0xd1, 0x9a, 0x20, 0xe8, 0x62, 0x22, 0x13, 0x36, +0xf7, 0xcd, 0x7f, 0x57, 0x7f, 0x46, 0xfd, 0xcc, 0xb6, 0xe2, 0x6c, 0x6d, +0x31, 0x5f, 0x8b, 0xd7, 0xd7, 0x10, 0xce, 0x09, 0xbd, 0xb6, 0x35, 0xf1, +0x5b, 0x0b, 0xf1, 0xe4, 0xdc, 0xd0, 0xa4, 0xbc, 0x99, 0x31, 0xf8, 0x19, +0x96, 0x1a, 0x36, 0x27, 0x3a, 0x8e, 0xfc, 0x67, 0xa1, 0x4f, 0x53, 0xc7, +0xcc, 0xb6, 0x91, 0x5e, 0xef, 0xa7, 0x7a, 0xc3, 0x12, 0xd4, 0xad, 0x5c, +0x8a, 0xfc, 0x3d, 0x33, 0xe9, 0xe7, 0x95, 0xdd, 0xe0, 0xbd, 0x21, 0x6f, +0x6a, 0x32, 0xbb, 0x53, 0xbd, 0x84, 0x6a, 0xf2, 0x3f, 0xd7, 0x23, 0xcc, +0xb1, 0x16, 0xe2, 0x08, 0xab, 0x7d, 0xb6, 0x84, 0x34, 0xf6, 0x0e, 0x7f, +0x2b, 0x81, 0x6b, 0xc7, 0x65, 0xe9, 0xca, 0xa0, 0x8c, 0xd7, 0xf5, 0xde, +0xf4, 0xe7, 0xd4, 0xd8, 0x7f, 0x6d, 0xde, 0xab, 0xff, 0x3c, 0x9c, 0x93, +0xe8, 0x90, 0x45, 0x2f, 0x49, 0xef, 0x59, 0x18, 0xd6, 0xce, 0x1f, 0x84, +0xe1, 0x33, 0x5d, 0x8c, 0xbc, 0x77, 0x30, 0xef, 0x9c, 0xf4, 0x53, 0xed, +0x22, 0x71, 0xf2, 0x14, 0xec, 0x2d, 0x08, 0x75, 0xbc, 0x8b, 0xc9, 0x5a, +0x9c, 0x7c, 0x2b, 0x21, 0xbb, 0x66, 0xe1, 0xc2, 0xaf, 0x0b, 0xfd, 0xca, +0x4d, 0x88, 0x2a, 0x62, 0xf7, 0x5a, 0x9e, 0xb3, 0x59, 0x08, 0x73, 0x26, +0x68, 0x6f, 0xe6, 0x67, 0xd7, 0x4d, 0x4a, 0xad, 0xe3, 0x0d, 0x91, 0xe8, +0x49, 0x1c, 0x34, 0x9e, 0xd8, 0x9b, 0x30, 0xd8, 0xb2, 0xdc, 0x57, 0xa1, +0xa3, 0x20, 0x5e, 0x7c, 0x66, 0xe2, 0xcf, 0x8d, 0x78, 0x0f, 0xb1, 0x8b, +0x19, 0xee, 0x76, 0x01, 0x0f, 0x3c, 0x93, 0x45, 0x43, 0x5a, 0x5b, 0x89, +0x59, 0x63, 0xaf, 0xc4, 0xf8, 0x16, 0xf3, 0x7e, 0xf6, 0x8b, 0x8b, 0x5f, +0x89, 0xca, 0x9d, 0x5b, 0xb0, 0x43, 0xaf, 0x7d, 0xbc, 0x21, 0x12, 0x8d, +0x73, 0x6b, 0x29, 0x86, 0x1e, 0xc3, 0x4b, 0x58, 0x0b, 0x1d, 0x19, 0x4f, +0xe1, 0xf2, 0xdd, 0xba, 0x95, 0x2c, 0x60, 0x9f, 0xac, 0x82, 0x93, 0xaf, +0x57, 0x9f, 0xed, 0x54, 0xc1, 0xb3, 0x2d, 0x25, 0x0c, 0xa1, 0x40, 0x3e, +0xc2, 0x9a, 0x36, 0x14, 0x58, 0xb1, 0xf7, 0x8a, 0x48, 0xb4, 0x9a, 0x6f, +0xa8, 0x75, 0x31, 0x73, 0x17, 0x12, 0xcc, 0x6b, 0xa5, 0x9e, 0x61, 0x99, +0x67, 0xe0, 0x29, 0xc4, 0x66, 0xaa, 0xf1, 0xf9, 0xb8, 0xb6, 0x2f, 0x96, +0x5f, 0x4a, 0xe7, 0x18, 0x5c, 0x1d, 0xc9, 0xd7, 0xbb, 0x11, 0x88, 0x5b, +0x20, 0x56, 0xb7, 0x8a, 0xe7, 0x34, 0x22, 0x81, 0xd7, 0x50, 0xc7, 0x41, +0xb5, 0x35, 0x4f, 0x21, 0x48, 0x30, 0x27, 0xdf, 0x01, 0x56, 0xf8, 0x7c, +0x5b, 0xad, 0x2c, 0x29, 0xea, 0x35, 0x14, 0xca, 0x33, 0xbc, 0x1a, 0x57, +0x7b, 0x16, 0xdb, 0xb9, 0x42, 0x8f, 0x02, 0x91, 0x60, 0xc2, 0x95, 0xf3, +0x12, 0xd6, 0x12, 0xcd, 0xfe, 0x67, 0x2d, 0xb1, 0x38, 0xde, 0x09, 0x2d, +0x5d, 0x1b, 0xa7, 0x25, 0x45, 0xd6, 0x08, 0x43, 0x6d, 0x5e, 0xd7, 0x91, +0x30, 0xe8, 0xbd, 0xc2, 0x8d, 0x0a, 0x22, 0x51, 0x73, 0x48, 0xa9, 0x45, +0x2f, 0x61, 0x4f, 0x49, 0xa5, 0xd6, 0xed, 0x6b, 0x2d, 0x76, 0xcc, 0x9c, +0x42, 0xcb, 0xb9, 0x88, 0x46, 0x43, 0x4b, 0x45, 0x77, 0xbf, 0x7e, 0xec, +0x4c, 0x1d, 0xcd, 0xfb, 0xa5, 0x32, 0x6f, 0x02, 0x91, 0xa8, 0x71, 0x90, +0xb4, 0xe2, 0x25, 0xbc, 0x4a, 0x30, 0x6f, 0xe5, 0x14, 0x6a, 0x10, 0x85, +0xda, 0x04, 0xb9, 0x31, 0xef, 0xe1, 0x56, 0x72, 0x9c, 0x16, 0xf4, 0x36, +0x73, 0x79, 0xb4, 0x35, 0x09, 0x05, 0x22, 0x51, 0xcb, 0xc0, 0xa8, 0x3d, +0xa4, 0xf4, 0xaa, 0xc7, 0xd1, 0x5a, 0x2f, 0xa1, 0xdc, 0x39, 0x85, 0xb3, +0xcf, 0xbe, 0x82, 0x09, 0x39, 0x33, 0x4e, 0x87, 0x16, 0x86, 0x6a, 0xc3, +0x4e, 0xdc, 0x27, 0x31, 0xf0, 0x6e, 0xcc, 0xed, 0xcc, 0x25, 0x3c, 0x2b, +0x43, 0xd5, 0xc3, 0x7a, 0x2b, 0x87, 0xa6, 0x9a, 0xe9, 0x1c, 0x59, 0x41, +0x1c, 0x1d, 0x71, 0x78, 0xbd, 0x48, 0xdd, 0x06, 0x5c, 0x1f, 0xaa, 0xa8, +0x76, 0x42, 0x24, 0x0a, 0x89, 0x43, 0x6d, 0xc9, 0xa9, 0x57, 0x77, 0x48, +0x84, 0x37, 0xad, 0x99, 0x24, 0x61, 0xeb, 0xb1, 0xe0, 0x99, 0xc9, 0xf7, +0x94, 0x22, 0xa7, 0xa2, 0x07, 0xf3, 0x1a, 0x6a, 0x5f, 0x27, 0x08, 0x37, +0xe5, 0x9c, 0x70, 0xb5, 0x84, 0x94, 0xc2, 0x5b, 0xd5, 0xd6, 0xc4, 0xc0, +0x86, 0x8c, 0x12, 0x9f, 0x4d, 0x28, 0x19, 0xfb, 0xed, 0xe9, 0xd4, 0x74, +0x54, 0xf1, 0x2c, 0x21, 0x0e, 0x03, 0x7b, 0x0d, 0xd5, 0xae, 0x19, 0xbc, +0x93, 0x3c, 0x14, 0x0f, 0x29, 0x6d, 0xdd, 0xb3, 0xac, 0x62, 0xb0, 0xd2, +0x6e, 0x61, 0xf2, 0x8b, 0x68, 0xaf, 0x83, 0xe3, 0x56, 0x30, 0x0f, 0x51, +0x73, 0x28, 0x2e, 0xbb, 0x67, 0x45, 0xa7, 0xd1, 0xba, 0x43, 0xd2, 0x5e, +0xa4, 0x10, 0x89, 0x14, 0x2f, 0xb7, 0xf4, 0x0e, 0x40, 0x9b, 0xfc, 0x85, +0xf7, 0x45, 0xac, 0x78, 0x06, 0x23, 0x0e, 0x80, 0xc5, 0x51, 0xde, 0x5a, +0x54, 0x1c, 0xfc, 0x18, 0xe4, 0xd6, 0xb3, 0x4a, 0xbd, 0x3a, 0x47, 0x4e, +0x22, 0x5d, 0x08, 0xa3, 0x94, 0x38, 0x84, 0x37, 0xcd, 0xe9, 0xa5, 0x21, +0x41, 0xfe, 0x80, 0x1d, 0x41, 0x81, 0xd6, 0x1b, 0x15, 0x4f, 0xb4, 0xec, +0xcf, 0xe2, 0x64, 0x07, 0xdb, 0xa1, 0xc7, 0x6b, 0xe1, 0xea, 0x3b, 0x72, +0x12, 0x2d, 0xab, 0xbd, 0xf5, 0x16, 0xac, 0x30, 0x98, 0x03, 0x46, 0x88, +0x42, 0xf9, 0x30, 0xd3, 0xc2, 0xc2, 0x43, 0xd8, 0xa2, 0xc5, 0x8d, 0xa7, +0x6b, 0xbb, 0x35, 0x4c, 0x1d, 0xe4, 0xae, 0x3e, 0x90, 0x89, 0x1d, 0xe6, +0x16, 0xcc, 0x35, 0x83, 0x33, 0x93, 0xb0, 0xae, 0xf7, 0x55, 0xa1, 0x40, +0x64, 0x17, 0x07, 0x12, 0x9f, 0x6d, 0x86, 0x47, 0x5d, 0x3b, 0x45, 0x16, +0x75, 0xee, 0x46, 0x73, 0x2b, 0xbb, 0xbd, 0x93, 0x59, 0x04, 0x42, 0xc2, +0x4a, 0x78, 0x0b, 0xc7, 0xbd, 0xbd, 0x81, 0x05, 0x62, 0xc2, 0x83, 0x62, +0xec, 0xba, 0x73, 0x79, 0x34, 0xf2, 0x46, 0x35, 0xba, 0x7d, 0x6b, 0xd5, +0x48, 0xf2, 0xff, 0x5c, 0x27, 0x78, 0xfe, 0xdd, 0x0d, 0xba, 0xfb, 0xca, +0x7a, 0x9a, 0x9c, 0x4a, 0xa5, 0xae, 0x44, 0x9e, 0x10, 0x61, 0x6d, 0x2f, +0x48, 0x85, 0xc1, 0x9e, 0x5b, 0x08, 0x84, 0x01, 0x45, 0x3f, 0xe9, 0xf9, +0xe5, 0x9a, 0x60, 0x15, 0x9d, 0xa0, 0xce, 0xea, 0xed, 0xfa, 0x9f, 0x9b, +0xb0, 0x44, 0x07, 0x1b, 0x54, 0x47, 0x65, 0x53, 0x5d, 0x71, 0xc0, 0x30, +0xf1, 0xac, 0xa1, 0x24, 0x84, 0x21, 0x1e, 0xb9, 0xf2, 0x10, 0x95, 0x94, +0xb8, 0x66, 0x3d, 0xa5, 0x8b, 0x38, 0xf4, 0xf9, 0x5e, 0x09, 0x19, 0x16, +0x7e, 0x19, 0x9a, 0x7c, 0x46, 0x18, 0xb2, 0x90, 0x25, 0x96, 0x5b, 0x43, +0x59, 0x67, 0xce, 0x45, 0xc4, 0xff, 0xbc, 0x88, 0x43, 0x67, 0x9b, 0x56, +0x44, 0xe2, 0x45, 0x48, 0x29, 0xb5, 0x3b, 0x67, 0xcf, 0x30, 0x68, 0x55, +0x52, 0xc5, 0x17, 0xa5, 0x10, 0x66, 0x6a, 0xc7, 0x25, 0xcf, 0x96, 0xd4, +0xe4, 0x00, 0x5c, 0xd9, 0xf7, 0x5c, 0x20, 0x2f, 0x31, 0x7c, 0x7e, 0x29, +0xf9, 0x91, 0xf7, 0x2d, 0xaf, 0x81, 0x9d, 0x58, 0x7a, 0x06, 0x10, 0x88, +0x9c, 0x49, 0x69, 0x76, 0x94, 0xe5, 0x29, 0xd1, 0x3e, 0x7c, 0x58, 0x91, +0xb8, 0xe7, 0xf0, 0x1a, 0x36, 0x84, 0x81, 0xc9, 0x96, 0x81, 0x1c, 0x49, +0xbe, 0x92, 0x02, 0x91, 0x31, 0x89, 0x49, 0xa5, 0x52, 0x65, 0xde, 0x44, +0xe6, 0x04, 0xf6, 0x70, 0x1b, 0xd9, 0xa4, 0xee, 0x9a, 0x0d, 0x27, 0xad, +0xe4, 0x19, 0x08, 0x27, 0xe5, 0x23, 0x79, 0xec, 0xb6, 0x60, 0x0e, 0x22, +0x57, 0x68, 0x89, 0xcd, 0xcc, 0xa0, 0xd1, 0x8f, 0x51, 0x45, 0x22, 0xd9, +0x43, 0x0d, 0xab, 0x93, 0x82, 0x92, 0x55, 0x84, 0x21, 0x3f, 0x53, 0xaf, +0x3b, 0xec, 0xde, 0xbd, 0x23, 0xd8, 0x3f, 0xc6, 0x07, 0xc9, 0xb5, 0xa5, +0x57, 0xdc, 0x54, 0x93, 0x6a, 0xad, 0x6c, 0xd5, 0xf4, 0x4b, 0x42, 0x18, +0x0a, 0xbe, 0xf3, 0x1c, 0x93, 0xa7, 0x40, 0xa9, 0x6b, 0x0e, 0xef, 0x81, +0xb0, 0x52, 0x43, 0xe3, 0x3c, 0x53, 0x6e, 0xa2, 0xdb, 0x31, 0x91, 0x44, +0x65, 0xe5, 0x6b, 0x86, 0x17, 0xf4, 0x18, 0xaf, 0x81, 0x09, 0x56, 0x01, +0x3d, 0xc6, 0xe9, 0x33, 0xfc, 0x4c, 0x8c, 0xdd, 0x36, 0xc9, 0x51, 0xe9, +0xd4, 0xdd, 0xd8, 0x48, 0xb2, 0xdb, 0x5a, 0x2b, 0x5b, 0xc5, 0x6b, 0xa8, +0x8f, 0xcc, 0x07, 0xe6, 0x72, 0x94, 0x80, 0xa6, 0xf6, 0x8a, 0xc8, 0x39, +0xb4, 0xcd, 0x9d, 0x0d, 0x44, 0xc1, 0xc5, 0x61, 0xcd, 0x6b, 0x30, 0xd5, +0x49, 0xd4, 0x88, 0x0f, 0xb2, 0x41, 0x70, 0xe5, 0x12, 0xd6, 0x77, 0xd7, +0xf1, 0xa1, 0x3f, 0xa8, 0x7f, 0xdc, 0xf7, 0xd0, 0xd8, 0x2f, 0x49, 0x4c, +0x4e, 0x3c, 0x84, 0x8d, 0x16, 0xdc, 0x24, 0xa1, 0x2b, 0xde, 0x51, 0xb9, +0xbe, 0x4e, 0xa0, 0xde, 0x52, 0x85, 0x4b, 0x19, 0xc3, 0x5d, 0x8e, 0xfd, +0x24, 0x45, 0x39, 0x4d, 0x8b, 0x44, 0x2a, 0x71, 0xe0, 0xb0, 0x5b, 0x9b, +0x14, 0x68, 0x7a, 0x36, 0x27, 0x9e, 0xf4, 0x9c, 0x90, 0x86, 0x23, 0x4c, +0x8e, 0xca, 0xa6, 0x3c, 0xe2, 0x10, 0x24, 0xa1, 0xd9, 0x71, 0xb5, 0x41, +0x4f, 0xbd, 0x6c, 0xa2, 0x4e, 0x76, 0xc4, 0x81, 0x90, 0x93, 0x1b, 0x28, +0x67, 0x15, 0x7d, 0x21, 0x08, 0xc5, 0x81, 0x09, 0xc5, 0x0e, 0xaa, 0xb0, +0x27, 0x11, 0x6d, 0x8c, 0x73, 0x49, 0x0c, 0x1b, 0xa5, 0x61, 0x44, 0x22, +0x55, 0x42, 0x5a, 0x73, 0x0e, 0x88, 0x03, 0x02, 0x71, 0xd2, 0xee, 0x15, +0x4f, 0x72, 0xca, 0x59, 0x11, 0x89, 0x21, 0xc6, 0x52, 0x12, 0xcf, 0x41, +0xc5, 0xc1, 0x5c, 0xfb, 0x49, 0x48, 0xa9, 0x4d, 0x6e, 0x25, 0x6e, 0xe8, +0x72, 0x69, 0x6e, 0x5d, 0x8b, 0x32, 0xd6, 0x39, 0x25, 0x3d, 0xf6, 0x86, +0x29, 0xd1, 0x7c, 0x58, 0x5c, 0x85, 0x39, 0xd9, 0x24, 0xb1, 0x35, 0x11, +0x07, 0x3d, 0x11, 0xed, 0xa8, 0x0d, 0x6f, 0x7e, 0x42, 0x94, 0xb8, 0x9d, +0x6b, 0x65, 0x41, 0x8e, 0xe1, 0x4d, 0x5c, 0x16, 0x08, 0x42, 0x4b, 0xe0, +0x12, 0x75, 0x86, 0xad, 0xad, 0x1a, 0x2e, 0xc9, 0xce, 0x50, 0xc2, 0x49, +0xe6, 0xbe, 0x06, 0xdc, 0x70, 0x42, 0x4c, 0xb1, 0xbd, 0x89, 0x2b, 0x8b, +0x73, 0x8c, 0x0d, 0x11, 0x63, 0x1a, 0x92, 0x45, 0x5f, 0xaa, 0xf1, 0x4e, +0x53, 0x28, 0xa0, 0x9e, 0x90, 0xe6, 0x5a, 0xc5, 0xee, 0xc8, 0x76, 0x60, +0xce, 0xed, 0xaf, 0x1e, 0x3a, 0x23, 0x16, 0x93, 0xe3, 0x30, 0x1c, 0x54, +0x2e, 0x12, 0x35, 0x6c, 0x42, 0xa2, 0xef, 0x0a, 0x35, 0xef, 0xe0, 0xc3, +0x4a, 0x88, 0x43, 0x87, 0x22, 0x51, 0x2a, 0x17, 0xf1, 0xcc, 0xab, 0xf0, +0x1b, 0x9d, 0xbd, 0x13, 0xea, 0xaa, 0xd7, 0x8c, 0xf7, 0x00, 0xab, 0xeb, +0x69, 0x82, 0x30, 0x6c, 0xb9, 0x30, 0x66, 0x2a, 0xef, 0xc1, 0x8b, 0x03, +0x93, 0xa8, 0xe3, 0x89, 0x50, 0x9b, 0x48, 0x04, 0xae, 0xf9, 0xab, 0x8d, +0xc9, 0xed, 0xe2, 0xf7, 0x61, 0xe3, 0x03, 0x9b, 0x63, 0x2b, 0xb2, 0x48, +0x14, 0x5b, 0x47, 0xa3, 0xe7, 0x1e, 0x44, 0x18, 0x10, 0x07, 0x5c, 0xea, +0x4a, 0x6c, 0x49, 0x31, 0xf6, 0xa9, 0x5c, 0x82, 0x9c, 0x6b, 0x6b, 0xc9, +0xf1, 0x16, 0x75, 0x82, 0xcb, 0x03, 0x21, 0x21, 0x3d, 0x16, 0xa5, 0xab, +0x9a, 0xae, 0xec, 0xf4, 0x2f, 0x7c, 0x76, 0xaa, 0xf1, 0x60, 0x0f, 0x51, +0xda, 0xb9, 0x14, 0x13, 0x88, 0xd8, 0x93, 0x1b, 0x71, 0x18, 0x73, 0x12, +0xc8, 0x00, 0xae, 0x35, 0xdc, 0xf4, 0x2c, 0x99, 0x7c, 0x36, 0xbc, 0x4a, +0xe1, 0x05, 0x1c, 0x60, 0x77, 0x28, 0xd6, 0x5c, 0xa9, 0x5c, 0xc7, 0x86, +0x24, 0xc1, 0xa4, 0x66, 0xd2, 0x20, 0x14, 0x35, 0x0a, 0xc5, 0x3d, 0xa6, +0x40, 0xb8, 0xf8, 0x67, 0x32, 0xa0, 0xf3, 0xb9, 0xf1, 0x6a, 0x33, 0xae, +0xb7, 0x69, 0x56, 0xe5, 0xb1, 0xc6, 0x9c, 0xcc, 0xc4, 0x65, 0xc1, 0x73, +0xf3, 0x8b, 0xa6, 0xda, 0xe4, 0x6d, 0x2e, 0x28, 0x20, 0x5b, 0x1b, 0x97, +0xc9, 0x71, 0x58, 0x0e, 0xf2, 0xcd, 0x8b, 0xcd, 0x90, 0xbe, 0x9c, 0x19, +0x93, 0xca, 0xcf, 0xaa, 0x36, 0xde, 0xb1, 0x26, 0x2b, 0x3d, 0xf0, 0xe1, +0xe0, 0x44, 0x99, 0x32, 0x8b, 0xc5, 0xd6, 0x0e, 0x2c, 0x4a, 0x22, 0x91, +0xcd, 0x11, 0xec, 0x65, 0xcd, 0x6b, 0x95, 0xd0, 0x92, 0xf6, 0xa9, 0x73, +0x35, 0x95, 0xb9, 0x46, 0x9c, 0xa0, 0xe4, 0x1d, 0xe0, 0xb4, 0x58, 0xc8, +0xf8, 0x49, 0x99, 0xec, 0x7e, 0xb6, 0x80, 0xc7, 0x28, 0xf3, 0x66, 0x83, +0x04, 0x67, 0x44, 0x42, 0xc3, 0x4a, 0x5b, 0xe2, 0xe0, 0xc7, 0xd5, 0x52, +0xfc, 0x83, 0xb2, 0x7b, 0x82, 0x4a, 0x98, 0x52, 0x9c, 0xcb, 0x79, 0x31, +0x46, 0x63, 0x9d, 0x0c, 0x67, 0x93, 0x04, 0x87, 0xc6, 0xba, 0x2c, 0xfe, +0x7a, 0x2c, 0x40, 0x2b, 0x40, 0x4d, 0x25, 0xe8, 0xe2, 0x2a, 0x08, 0x5d, +0xde, 0xaf, 0x78, 0x11, 0x7e, 0xd7, 0xc7, 0xce, 0x09, 0xaa, 0x16, 0x8a, +0x57, 0x9b, 0x98, 0x48, 0xdf, 0x8b, 0xd2, 0x57, 0x38, 0x2b, 0x14, 0x7a, +0x69, 0x9a, 0xb5, 0x7a, 0x3e, 0xe0, 0x19, 0x91, 0x20, 0x39, 0x07, 0x0d, +0x09, 0xc5, 0xab, 0xc5, 0xfb, 0x7e, 0x35, 0xdc, 0x8a, 0x27, 0x0d, 0x3d, +0x73, 0xc6, 0xcd, 0xc6, 0xa5, 0x86, 0x6c, 0xe3, 0x53, 0xbc, 0x55, 0x59, +0xc4, 0xf5, 0xd7, 0x83, 0x0b, 0xfa, 0x9e, 0x8d, 0xcc, 0xa5, 0x1e, 0x3a, +0x08, 0x04, 0xf4, 0xce, 0x91, 0x53, 0xd5, 0xb8, 0xd3, 0x50, 0x82, 0x9b, +0xf9, 0x55, 0xcb, 0x69, 0xd5, 0x45, 0x5f, 0x64, 0x91, 0xb6, 0x02, 0x62, +0x3a, 0xbd, 0x1e, 0x75, 0xf9, 0x97, 0x13, 0x1e, 0x05, 0x73, 0x02, 0x10, +0x09, 0x26, 0x02, 0x34, 0x22, 0x24, 0x57, 0xe3, 0xb8, 0xef, 0x5e, 0x8b, +0x23, 0x17, 0x07, 0xf0, 0x77, 0x62, 0xac, 0x4d, 0x0a, 0x3f, 0x09, 0x26, +0x1e, 0x0f, 0x0c, 0x28, 0x36, 0x93, 0xdf, 0x18, 0x3d, 0xbc, 0x14, 0x6b, +0x8e, 0x50, 0x2b, 0x0c, 0x3a, 0x29, 0x66, 0x9d, 0x14, 0x08, 0x03, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x40, 0x72, 0x26, 0x1e, 0x01, 0x00, 0x00, 0x84, 0xdc, 0xff, 0xd8, +0xc2, 0x63, 0x00, 0x00, 0x80, 0x0f, 0x7c, 0xfd, 0xfa, 0xf5, 0x3f, 0x08, +0x04, 0x00, 0x00, 0x84, 0x4c, 0x7f, 0xec, 0xed, 0x8f, 0xcd, 0x3c, 0x0a, +0x00, 0x00, 0x78, 0x17, 0x87, 0x6f, 0xdf, 0xbe, 0xfd, 0x0f, 0x81, 0x00, +0x00, 0x80, 0x2d, 0x71, 0x78, 0x73, 0x24, 0xa9, 0x01, 0x00, 0x86, 0xe7, +0xee, 0x73, 0x0e, 0x2a, 0x0c, 0x6f, 0x5e, 0x28, 0x6e, 0x3c, 0x1a, 0x00, +0x00, 0x84, 0xe1, 0x6d, 0x45, 0x20, 0x00, 0x00, 0x60, 0x30, 0xa6, 0x2d, +0x61, 0x50, 0xf3, 0x7f, 0x0e, 0x00, 0x00, 0xa3, 0x08, 0xc3, 0x97, 0x2f, +0x5f, 0xfe, 0xfb, 0x4c, 0x18, 0x8c, 0x51, 0xe2, 0x0a, 0x00, 0x30, 0x00, +0xf3, 0x01, 0x61, 0xd0, 0xf0, 0xd2, 0x9d, 0xc7, 0x06, 0x00, 0x80, 0x30, +0x10, 0x5e, 0x02, 0x00, 0x18, 0x84, 0xe9, 0x8c, 0x30, 0x18, 0xe3, 0xfc, +0x03, 0x00, 0x40, 0x87, 0x2c, 0xc1, 0x59, 0x86, 0x43, 0x46, 0x79, 0x2b, +0x00, 0x40, 0x7f, 0xdc, 0x5e, 0x55, 0x26, 0xb9, 0xf2, 0xe1, 0xa5, 0xbb, +0x23, 0xb7, 0x01, 0x00, 0xd0, 0x8e, 0xd7, 0xe0, 0xf2, 0x85, 0x97, 0xe4, +0x6b, 0x53, 0x1d, 0x05, 0x00, 0x90, 0x83, 0x18, 0x5e, 0x83, 0x4b, 0x5f, +0xbd, 0xf4, 0x68, 0x1d, 0xee, 0xf3, 0x22, 0x78, 0x10, 0x00, 0x00, 0x89, +0x79, 0x84, 0x94, 0xbe, 0x7f, 0xff, 0xfe, 0x4f, 0x44, 0xef, 0xe1, 0xd5, +0xee, 0xfe, 0xb6, 0xc3, 0x26, 0x63, 0xb3, 0x7c, 0x46, 0xf9, 0x7c, 0xe4, +0x36, 0x00, 0x00, 0xf2, 0x70, 0x97, 0xdd, 0xf8, 0xb2, 0x2c, 0x6f, 0x22, +0x10, 0xb1, 0xbc, 0x07, 0xef, 0x8d, 0x84, 0x3b, 0xfc, 0xc7, 0x22, 0x2f, +0xdf, 0x4f, 0x17, 0xfa, 0x67, 0xb6, 0xf5, 0xf5, 0xbd, 0xf7, 0x00, 0x00, +0x00, 0x09, 0x79, 0x74, 0x5c, 0xfd, 0xf5, 0xeb, 0xd7, 0x9b, 0x08, 0x44, +0x0c, 0x71, 0x10, 0x91, 0x91, 0xaf, 0xf7, 0xfb, 0xf7, 0x6f, 0xfd, 0x9a, +0x92, 0x2b, 0xb8, 0x5a, 0x2a, 0x4b, 0xe9, 0x2c, 0x00, 0x40, 0x46, 0x6e, +0xb2, 0x68, 0xcb, 0x62, 0xfe, 0xf3, 0xe7, 0xcf, 0x58, 0x0b, 0xf7, 0x43, +0x20, 0x7e, 0xfc, 0xf8, 0xf1, 0x8f, 0x7c, 0x4d, 0x11, 0x09, 0xf9, 0xfa, +0xf2, 0xff, 0x2e, 0x6e, 0x6e, 0x03, 0x00, 0x00, 0x52, 0x8a, 0x83, 0x2e, +0xe2, 0x11, 0x77, 0xf6, 0x9f, 0x16, 0x73, 0xfd, 0x1e, 0x11, 0x45, 0x88, +0xca, 0x25, 0x00, 0x80, 0x54, 0x48, 0x1e, 0x40, 0xc2, 0x3f, 0xb2, 0x70, +0xc7, 0xdc, 0xdd, 0x6f, 0x99, 0x7c, 0x8f, 0x18, 0x22, 0x41, 0xee, 0x01, +0x00, 0x20, 0x2d, 0x93, 0x84, 0x81, 0x22, 0xef, 0xea, 0x77, 0x85, 0x9e, +0x22, 0x7c, 0xcf, 0x89, 0xd7, 0x07, 0x00, 0x90, 0x86, 0x9b, 0x26, 0xa5, +0x73, 0x79, 0x0f, 0x6b, 0x22, 0x71, 0x32, 0x21, 0x4e, 0x68, 0x09, 0x00, +0x20, 0x15, 0x36, 0xb4, 0x94, 0xd3, 0x7b, 0x58, 0x13, 0x89, 0x23, 0x25, +0xb5, 0x74, 0x84, 0x05, 0x00, 0x48, 0xcb, 0xac, 0xb9, 0x00, 0xf1, 0x20, +0x22, 0x1e, 0x88, 0x3b, 0x95, 0x93, 0xd8, 0x2b, 0x50, 0x3e, 0xef, 0xc0, +0xa1, 0x38, 0x00, 0x80, 0x44, 0xdc, 0x4b, 0x86, 0x96, 0xb6, 0x44, 0xe2, +0xd5, 0xe7, 0xa0, 0x9d, 0x06, 0x00, 0x40, 0x5a, 0x3e, 0x94, 0xb4, 0xc6, +0x3a, 0x10, 0x17, 0x4b, 0x24, 0xb6, 0x3c, 0x19, 0x3c, 0x07, 0x00, 0x80, +0xc4, 0xd4, 0x90, 0x77, 0x70, 0x4f, 0xce, 0x49, 0x84, 0xb9, 0x08, 0x2f, +0x18, 0x0b, 0xe2, 0x00, 0x00, 0x90, 0x8e, 0x29, 0x14, 0x87, 0x92, 0x79, +0x07, 0xf7, 0x3a, 0x09, 0xfd, 0x68, 0xc9, 0xc1, 0x6b, 0x03, 0x00, 0x48, +0xc7, 0x5d, 0x3b, 0xb3, 0xda, 0x53, 0xcc, 0xb5, 0x8a, 0x83, 0xe3, 0x00, +0x1c, 0x00, 0x40, 0x52, 0x24, 0x1c, 0xb3, 0x88, 0x30, 0x68, 0x85, 0x90, +0xf6, 0x58, 0xaa, 0x21, 0x21, 0xed, 0xf6, 0xf5, 0x57, 0xc2, 0x7b, 0x00, +0x00, 0x88, 0x28, 0x0a, 0xb3, 0x7a, 0x0b, 0xa1, 0x30, 0xc4, 0x6a, 0xdd, +0xed, 0x22, 0x9f, 0x81, 0x70, 0x1c, 0x84, 0x03, 0x00, 0x48, 0x86, 0xec, +0xb4, 0x1f, 0x37, 0xaa, 0xa9, 0x30, 0x48, 0x9e, 0x41, 0x7e, 0xad, 0x51, +0x14, 0xac, 0x38, 0x3c, 0x4b, 0x92, 0x73, 0x09, 0x10, 0x00, 0xc0, 0x79, +0xde, 0xbd, 0x05, 0x6b, 0xae, 0xf2, 0xf0, 0x91, 0x0b, 0x1a, 0xf6, 0xbd, +0xc8, 0x85, 0x70, 0xe6, 0x01, 0x00, 0xe0, 0x88, 0xc7, 0xa0, 0x97, 0xed, +0xb4, 0x24, 0x0a, 0xda, 0xea, 0x5b, 0x73, 0x20, 0x2a, 0x10, 0x2f, 0x3e, +0xff, 0xc4, 0xeb, 0x06, 0x00, 0xd8, 0xe9, 0x35, 0xb4, 0xe2, 0x21, 0xb8, +0x8d, 0x7b, 0x20, 0xf4, 0x60, 0x9e, 0x0a, 0xc4, 0xb3, 0x83, 0x7a, 0xf4, +0x5c, 0x02, 0x00, 0x78, 0xcd, 0xdd, 0x2f, 0x96, 0x6f, 0x2d, 0x9a, 0x8a, +0x83, 0x15, 0x84, 0x3d, 0x87, 0xf5, 0xc8, 0x43, 0x00, 0x00, 0xac, 0x23, +0x0b, 0x63, 0xec, 0xbb, 0x9b, 0x8b, 0x35, 0xe2, 0xdb, 0x12, 0x08, 0xa9, +0xb2, 0x72, 0xdc, 0xf9, 0x00, 0x70, 0x79, 0xb1, 0x10, 0xbb, 0xfb, 0x09, +0x13, 0xda, 0xbc, 0xf2, 0x7b, 0x77, 0xf3, 0xef, 0xa0, 0xad, 0x77, 0xbd, +0xd4, 0x7c, 0x90, 0xcd, 0x1d, 0x4c, 0x44, 0x4b, 0x9e, 0x41, 0xcb, 0x6d, +0xf5, 0xe7, 0xb2, 0x77, 0x54, 0x3f, 0xfb, 0x59, 0x09, 0x33, 0x01, 0xf8, +0xdd, 0xa2, 0x5f, 0xe8, 0x1f, 0x07, 0x9c, 0x64, 0xe7, 0xa8, 0x26, 0x13, +0xe8, 0xcc, 0x82, 0xa1, 0xff, 0x4e, 0xbf, 0x8e, 0x7c, 0x5d, 0x3f, 0xe1, +0x96, 0x40, 0x54, 0x10, 0x92, 0x0c, 0x61, 0x22, 0xff, 0xcc, 0x6f, 0xcf, +0xc2, 0x48, 0x3d, 0x08, 0x83, 0xf5, 0x10, 0xb6, 0xf2, 0x0c, 0xda, 0x49, +0xf6, 0x55, 0xa2, 0x9a, 0x30, 0x13, 0x0c, 0x29, 0x04, 0x56, 0x04, 0x4a, +0x2f, 0x0a, 0x6b, 0x42, 0xe2, 0x45, 0x64, 0x31, 0x02, 0x02, 0xc7, 0xbc, +0xbd, 0x0f, 0xef, 0xd9, 0x7d, 0x6e, 0x3e, 0xa7, 0x22, 0x3d, 0xd7, 0x30, +0x06, 0x62, 0x8f, 0x27, 0x5d, 0xfc, 0xb7, 0x44, 0x60, 0xaf, 0x40, 0x38, +0xca, 0x5d, 0xa1, 0x73, 0x31, 0x78, 0xf7, 0x08, 0x5a, 0x5d, 0x04, 0xac, +0x80, 0xac, 0x78, 0x20, 0x36, 0x94, 0x75, 0xeb, 0xf8, 0x5d, 0xda, 0xf0, +0x9e, 0x2e, 0xf0, 0xd1, 0xbc, 0xbd, 0x9e, 0x4c, 0x6f, 0x89, 0xb3, 0x16, +0xf6, 0x7f, 0x3a, 0x28, 0x10, 0x33, 0xcb, 0x09, 0xf4, 0xc0, 0xd4, 0xba, +0x18, 0x5c, 0x11, 0x10, 0xeb, 0x85, 0x84, 0x61, 0xad, 0x20, 0xbc, 0x15, +0xda, 0xb4, 0x62, 0xb7, 0x84, 0xc2, 0x73, 0x0b, 0x76, 0xfa, 0x1f, 0x16, +0x7e, 0xfd, 0xac, 0xb5, 0x78, 0x78, 0xae, 0xe1, 0xfc, 0x83, 0x35, 0x11, +0x05, 0xbd, 0x18, 0xe8, 0x99, 0x77, 0x41, 0x98, 0x09, 0xba, 0x08, 0x13, +0xd9, 0xc5, 0xa4, 0xe5, 0x32, 0xc4, 0xda, 0x45, 0x47, 0x4d, 0x17, 0x6d, +0xbb, 0x80, 0x1f, 0xf9, 0x6f, 0x2b, 0xde, 0xec, 0xf4, 0xf3, 0x78, 0x12, +0xda, 0xfa, 0xc3, 0x7a, 0x0c, 0xd6, 0xab, 0xd8, 0xdb, 0x3c, 0x90, 0x64, +0x35, 0x54, 0xeb, 0x15, 0x84, 0xbb, 0xca, 0x60, 0x27, 0x3c, 0x9b, 0x70, +0xcb, 0x3c, 0xa2, 0x07, 0x81, 0x61, 0x67, 0x44, 0xff, 0xe8, 0xbf, 0xf7, +0xf3, 0x0e, 0x4f, 0x02, 0xea, 0x09, 0x17, 0x05, 0x42, 0x70, 0x7f, 0x96, +0x67, 0x40, 0x14, 0x30, 0x2c, 0xcb, 0x5d, 0x11, 0x24, 0xad, 0xa1, 0x8a, +0x50, 0xd2, 0x6d, 0xe5, 0xf7, 0x1e, 0xa1, 0x25, 0xbc, 0x04, 0x0c, 0xe3, +0xbe, 0x08, 0x80, 0xbb, 0x86, 0x8e, 0x10, 0x04, 0x0c, 0xab, 0xca, 0xa8, +0x6e, 0x82, 0xb2, 0xa2, 0xc0, 0x24, 0xc4, 0x30, 0x44, 0x02, 0xe0, 0x21, +0x0a, 0xad, 0xf7, 0xbe, 0xc1, 0xb0, 0xc1, 0x8c, 0x9b, 0xe7, 0x20, 0x29, +0x13, 0x9e, 0x02, 0x86, 0x21, 0x10, 0x00, 0x1f, 0x84, 0x01, 0x6f, 0x01, +0xc3, 0xda, 0x36, 0xce, 0x47, 0x40, 0x4c, 0x6e, 0x84, 0x91, 0x30, 0x0c, +0x81, 0x00, 0x20, 0xbf, 0x80, 0x61, 0x08, 0x04, 0xc0, 0xb6, 0x30, 0x50, +0x9e, 0x8a, 0x61, 0x5d, 0xdb, 0xc4, 0x32, 0x07, 0x47, 0xc1, 0x5b, 0xc0, +0x30, 0xbc, 0x07, 0x80, 0x0f, 0xf9, 0x85, 0x05, 0x61, 0xc0, 0xb0, 0x61, +0x4e, 0x53, 0xd3, 0x72, 0x03, 0x76, 0xe5, 0x17, 0x16, 0xc2, 0x48, 0x18, +0x46, 0x79, 0x2b, 0xc0, 0x87, 0x30, 0x12, 0xc2, 0x80, 0x61, 0x43, 0x36, +0xec, 0xa3, 0xab, 0x2b, 0xac, 0x7b, 0x0b, 0x84, 0x91, 0x30, 0x8c, 0xf6, +0x1a, 0x00, 0xca, 0x44, 0x35, 0x12, 0x86, 0x61, 0x24, 0xa6, 0x81, 0xa4, +0x33, 0x86, 0x61, 0xdc, 0x05, 0x01, 0xeb, 0xde, 0x42, 0x8d, 0x49, 0x67, +0xf2, 0x1d, 0x18, 0xc6, 0x99, 0x07, 0x28, 0x97, 0x5b, 0xa8, 0xea, 0xec, +0x82, 0xde, 0x81, 0xec, 0xfe, 0xad, 0x96, 0x78, 0x7c, 0x3e, 0x04, 0x02, +0xc3, 0xa8, 0x5a, 0x82, 0x7c, 0x21, 0xa4, 0x6a, 0xee, 0x5c, 0x90, 0xc5, +0xdf, 0xdc, 0x37, 0x3d, 0x3b, 0x53, 0x25, 0x41, 0xb7, 0x57, 0x0c, 0x2b, +0x7a, 0xde, 0x81, 0xa4, 0xf4, 0x60, 0xde, 0x42, 0xf1, 0x10, 0xd2, 0x8a, +0x20, 0xac, 0xc5, 0x36, 0x6f, 0xe4, 0x40, 0x30, 0xac, 0x68, 0x42, 0x9a, +0x9c, 0xc3, 0x48, 0xc2, 0x50, 0x49, 0xd8, 0x68, 0x72, 0xaf, 0xeb, 0xa8, +0x11, 0x07, 0x0c, 0x2b, 0xb0, 0x69, 0x33, 0x61, 0x5d, 0x18, 0x20, 0x8c, +0x54, 0xf4, 0xde, 0x85, 0x60, 0xc0, 0xed, 0x3d, 0x5c, 0x83, 0x38, 0x60, +0x58, 0xc4, 0x85, 0x3f, 0x34, 0x99, 0x5f, 0xc6, 0x83, 0x5f, 0x76, 0x6e, +0xda, 0x80, 0x30, 0x52, 0x54, 0x4f, 0xe1, 0xcc, 0x2e, 0x04, 0x71, 0xc0, +0xb0, 0x7d, 0x1b, 0xaf, 0xd9, 0x2f, 0xec, 0xaf, 0xec, 0x66, 0x0c, 0x46, +0x16, 0x85, 0x0a, 0xbc, 0x85, 0x4b, 0x3b, 0x11, 0x12, 0xd2, 0x18, 0xf6, +0x32, 0x69, 0x4c, 0x45, 0x11, 0xec, 0x0e, 0x21, 0xd5, 0x50, 0x9e, 0x1a, +0x2b, 0x66, 0x39, 0xb1, 0x08, 0x60, 0x18, 0xe5, 0xa6, 0x10, 0x41, 0x14, +0x4a, 0x56, 0x22, 0x99, 0x9d, 0x4c, 0xac, 0x64, 0xd6, 0x8d, 0x73, 0x0e, +0x18, 0xf6, 0xd2, 0x48, 0x1e, 0xc3, 0x76, 0xf8, 0xa8, 0xf4, 0x22, 0x1a, +0x23, 0x8c, 0xb4, 0x06, 0x79, 0x07, 0x0c, 0xa3, 0x0f, 0x12, 0x1c, 0xf0, +0x12, 0x64, 0x40, 0xd4, 0xb2, 0x70, 0x1a, 0x61, 0x48, 0xc1, 0xc2, 0x02, +0x80, 0x61, 0xb4, 0xba, 0x80, 0x6d, 0x41, 0x90, 0x97, 0xbf, 0xd4, 0xd6, +0x35, 0xd5, 0x9c, 0x5b, 0x48, 0xe9, 0x1d, 0x31, 0xf9, 0x31, 0xec, 0x75, +0x48, 0x97, 0x2a, 0x24, 0x04, 0xa1, 0xaa, 0x64, 0x58, 0xf2, 0x1d, 0x0b, +0x55, 0x4b, 0x18, 0x46, 0x72, 0x1a, 0x41, 0xa8, 0x5f, 0x10, 0x52, 0x24, +0x9e, 0x5f, 0x31, 0x31, 0xf1, 0x31, 0x8c, 0xe4, 0xf4, 0x88, 0x49, 0xe5, +0xb9, 0x76, 0x41, 0x70, 0x9f, 0x0f, 0xdd, 0x64, 0x1d, 0x84, 0x78, 0x0f, +0x18, 0xb6, 0x7b, 0x7e, 0x42, 0xa3, 0x42, 0x30, 0xb5, 0x24, 0x06, 0x2b, +0xf9, 0x85, 0x52, 0x9d, 0x1a, 0x67, 0x26, 0x3f, 0x86, 0xbd, 0xf4, 0xe8, +0xa9, 0x5e, 0x6a, 0x24, 0x3c, 0xd4, 0xac, 0x10, 0xb8, 0xed, 0x86, 0x79, +0xa5, 0x20, 0xb4, 0x84, 0x61, 0x4f, 0xec, 0xc7, 0x8f, 0x1f, 0xff, 0x7c, +0xff, 0xfe, 0xfd, 0x1f, 0xff, 0xff, 0xb4, 0xdb, 0xae, 0x40, 0x04, 0x6e, +0x46, 0x04, 0x1e, 0x42, 0xd0, 0xd3, 0x2d, 0x66, 0x26, 0xbf, 0x50, 0xba, +0x12, 0x82, 0x03, 0x71, 0x18, 0xf6, 0xc2, 0x7e, 0xfd, 0xfa, 0xf5, 0x66, +0x04, 0x82, 0xfc, 0x43, 0xea, 0x45, 0x49, 0x76, 0xcd, 0xa6, 0x73, 0xe1, +0xa2, 0x9e, 0x80, 0x8a, 0x40, 0xaf, 0x8b, 0x96, 0xe9, 0xa6, 0x5a, 0x45, +0x89, 0x1c, 0x79, 0x07, 0x0c, 0x7b, 0x6e, 0x22, 0x0c, 0xbf, 0x7f, 0xff, +0xb6, 0xde, 0x3e, 0x10, 0xef, 0x4e, 0x96, 0x78, 0xae, 0x09, 0x42, 0x4b, +0x18, 0xf6, 0xc2, 0x7e, 0xfe, 0xfc, 0xf9, 0xf0, 0x20, 0x1c, 0x87, 0xe3, +0x10, 0x88, 0x84, 0xc2, 0x50, 0xdb, 0xa1, 0x1a, 0xda, 0x78, 0x63, 0xd8, +0x0e, 0x13, 0xef, 0x61, 0x59, 0x16, 0x92, 0xd3, 0x99, 0x73, 0x0c, 0x78, +0x0c, 0x65, 0xa1, 0x9d, 0x06, 0x86, 0xed, 0x0c, 0x2f, 0x49, 0x92, 0x9a, +0xdc, 0x03, 0x5e, 0x44, 0xac, 0xe4, 0x73, 0xed, 0x55, 0x0e, 0x24, 0xa6, +0x31, 0x6c, 0x87, 0x89, 0xe7, 0x20, 0x02, 0xe1, 0x13, 0xd4, 0x08, 0x44, +0xee, 0x18, 0x78, 0x2f, 0x61, 0x8e, 0x8a, 0x43, 0x49, 0x24, 0xa6, 0x31, +0xec, 0x82, 0xf7, 0x20, 0xe6, 0xe7, 0x37, 0xbd, 0x97, 0x4a, 0xec, 0x66, +0x5b, 0x5d, 0xb0, 0x4a, 0x9d, 0x78, 0x26, 0xbc, 0x87, 0x61, 0xf9, 0xbc, +0x07, 0xf9, 0xd5, 0xd1, 0x7b, 0xa9, 0xbc, 0x37, 0x51, 0xbb, 0x50, 0x98, +0xb3, 0x0b, 0x53, 0xab, 0xee, 0x26, 0xde, 0x03, 0x86, 0xed, 0x3f, 0xfb, +0x40, 0x78, 0xa9, 0x3e, 0x1e, 0x97, 0xf1, 0xd4, 0x12, 0x23, 0x0f, 0x44, +0xa1, 0x87, 0x67, 0xcb, 0xe4, 0xc7, 0xb0, 0x9d, 0xe1, 0x25, 0x29, 0x71, +0xa5, 0x7a, 0xa9, 0xde, 0x50, 0xc8, 0x54, 0x42, 0x2c, 0xcc, 0x61, 0xb6, +0x26, 0x72, 0x0a, 0x78, 0x0f, 0x18, 0x16, 0xbf, 0xb5, 0x86, 0xf1, 0x1e, +0x26, 0x96, 0xe3, 0x36, 0xc4, 0x62, 0x8e, 0xd9, 0x77, 0x49, 0xbe, 0x8e, +0x88, 0x81, 0x69, 0x92, 0xd7, 0x6c, 0xe8, 0x68, 0xcf, 0x33, 0xa4, 0x72, +0x09, 0xc3, 0x8e, 0x1d, 0x8e, 0xa3, 0x73, 0x6b, 0xbb, 0x82, 0x61, 0x3b, +0xb7, 0x6e, 0xd9, 0x12, 0xd8, 0x6c, 0x84, 0x60, 0x72, 0x03, 0x55, 0x25, +0xe0, 0x3d, 0x60, 0xd8, 0xa9, 0xb3, 0x0f, 0x34, 0xe6, 0x83, 0xee, 0xa1, +0x95, 0x37, 0x86, 0x1d, 0x0c, 0x2f, 0x71, 0xad, 0x28, 0x0c, 0xe1, 0x6d, +0x11, 0x5a, 0xc2, 0xb0, 0x63, 0xd5, 0x4b, 0x62, 0x24, 0xa7, 0x61, 0x04, +0x68, 0xa9, 0x81, 0x61, 0x07, 0xc3, 0x4b, 0xfe, 0xec, 0x03, 0xa5, 0xad, +0xd0, 0x35, 0x94, 0xb5, 0x62, 0xd8, 0xc1, 0xe4, 0xb4, 0x11, 0x08, 0xc2, +0x4b, 0xd0, 0x2f, 0x74, 0x6b, 0xc5, 0xb0, 0xe3, 0xb9, 0x07, 0x93, 0xa0, +0x46, 0x20, 0xa0, 0x5b, 0x48, 0x4c, 0x63, 0xd8, 0x89, 0xd6, 0x1a, 0x94, +0xb7, 0x42, 0xef, 0x4c, 0x4c, 0x78, 0x0c, 0x3b, 0xd7, 0x98, 0x8f, 0xd3, +0xd3, 0xd0, 0x75, 0xde, 0x81, 0xd0, 0x12, 0x86, 0x9d, 0xf3, 0x1e, 0x10, +0x08, 0xe8, 0x5a, 0x1c, 0x28, 0x69, 0xc5, 0xb0, 0xf3, 0xc9, 0x69, 0x6e, +0x8f, 0x83, 0x6e, 0xc3, 0x4a, 0x88, 0x03, 0x86, 0x5d, 0x0b, 0x2f, 0x99, +0xfe, 0x4b, 0xb4, 0xf7, 0x86, 0xe6, 0x91, 0x2a, 0x8b, 0x99, 0x90, 0x12, +0x86, 0xc5, 0xa9, 0x5e, 0x32, 0x02, 0x41, 0x8b, 0x0d, 0x68, 0x56, 0x14, +0xa6, 0x98, 0x4d, 0x0b, 0x31, 0x8c, 0xfc, 0xc3, 0x27, 0x81, 0x98, 0x58, +0x6a, 0xa0, 0x05, 0x31, 0x78, 0x6f, 0x7b, 0x2e, 0x9e, 0x02, 0xa2, 0x80, +0x61, 0x08, 0x04, 0x0c, 0x1a, 0x2e, 0x12, 0x21, 0x10, 0xef, 0x40, 0xc5, +0x00, 0x41, 0xc0, 0x30, 0x04, 0x02, 0xc6, 0x65, 0x26, 0x5c, 0x84, 0xa5, +0x32, 0x19, 0x57, 0xb2, 0xe0, 0xa9, 0x49, 0xbc, 0x5d, 0x16, 0xc4, 0x2d, +0x93, 0x3f, 0xb7, 0x7f, 0x3f, 0x34, 0xdd, 0xb4, 0x58, 0x43, 0x20, 0x00, +0xe2, 0x33, 0x91, 0x5c, 0xc6, 0x62, 0x99, 0x2c, 0x6a, 0xba, 0xc8, 0x4b, +0xc9, 0xa6, 0x5e, 0x78, 0x63, 0x17, 0xbe, 0x58, 0xa6, 0xdd, 0x4e, 0xf5, +0xfb, 0x58, 0x51, 0x91, 0xff, 0xb6, 0xa6, 0xbf, 0xdf, 0xa0, 0x40, 0xd0, +0xa8, 0x0f, 0xca, 0x84, 0x92, 0xb8, 0xbc, 0x07, 0xbb, 0xea, 0x11, 0xa8, +0x27, 0x10, 0x43, 0x08, 0x74, 0xc1, 0xd7, 0x45, 0x7f, 0xcd, 0xab, 0x08, +0x17, 0xfd, 0x3d, 0x9e, 0x43, 0x2b, 0xde, 0xc5, 0x86, 0x40, 0xd0, 0x87, +0x09, 0xf0, 0x1a, 0xb0, 0xba, 0xc3, 0x42, 0xba, 0x28, 0x9f, 0x15, 0x03, +0xbb, 0xd3, 0x0f, 0x17, 0x7c, 0xbd, 0x72, 0x57, 0x4d, 0x36, 0x2e, 0x6a, +0x23, 0x85, 0x3c, 0x6d, 0x99, 0xab, 0x3c, 0x2f, 0x2e, 0x0a, 0x82, 0x22, +0xb9, 0x06, 0x16, 0x3f, 0x4c, 0x05, 0xc0, 0x7a, 0x02, 0x67, 0x05, 0x20, +0x0c, 0xf5, 0xa8, 0x08, 0xe8, 0x2e, 0x3f, 0x5c, 0xf8, 0xdd, 0xdf, 0xab, +0x77, 0x27, 0x1f, 0x42, 0xb9, 0x6d, 0x2d, 0x84, 0x23, 0x6d, 0x64, 0x10, +0x08, 0x28, 0x0d, 0x97, 0xf6, 0x24, 0x8a, 0xbb, 0xd7, 0xb8, 0xd3, 0x5d, +0x5b, 0xfc, 0x43, 0x01, 0xb0, 0xbf, 0x86, 0x0b, 0xfd, 0xb3, 0x10, 0x8f, +0xfe, 0xcc, 0x6b, 0x3b, 0xff, 0x0d, 0x01, 0x38, 0xc3, 0x7d, 0xb4, 0x71, +0x44, 0x88, 0x09, 0x10, 0x87, 0x8e, 0x92, 0xb1, 0x61, 0x72, 0x34, 0xa7, +0x50, 0x58, 0x0f, 0x60, 0x2d, 0x1f, 0xb0, 0xb5, 0xf8, 0x87, 0x95, 0x42, +0x5a, 0xca, 0x1c, 0x2e, 0xf6, 0x66, 0xa1, 0xd7, 0xc5, 0x7e, 0xda, 0xb3, +0xeb, 0x8f, 0x19, 0x0a, 0x1d, 0xcd, 0xa3, 0xb3, 0x9e, 0x9b, 0xbf, 0x0b, +0x62, 0x62, 0xe9, 0x02, 0xc4, 0xa1, 0x21, 0x61, 0xd0, 0x86, 0x6a, 0xf2, +0xab, 0x0a, 0x45, 0x18, 0x72, 0x09, 0xcb, 0x31, 0xcf, 0x2c, 0xfc, 0x6b, +0x8b, 0xff, 0x9a, 0x07, 0x10, 0x2e, 0xfe, 0x5b, 0x3b, 0x7c, 0x1f, 0xae, +0xd1, 0x05, 0x7f, 0x8e, 0xb0, 0xc3, 0xef, 0x7e, 0xdc, 0xe6, 0xf6, 0x0c, +0xc3, 0x66, 0x7d, 0x8e, 0x56, 0x1b, 0x90, 0x12, 0x2a, 0x95, 0xe2, 0x2d, +0x14, 0x56, 0x08, 0xfc, 0xee, 0xee, 0xc3, 0x84, 0xde, 0x9b, 0xa4, 0x0d, +0xe3, 0xf5, 0xd6, 0xb6, 0x62, 0xff, 0x7b, 0x44, 0xc0, 0xec, 0xfa, 0x73, +0xee, 0xf2, 0x53, 0x71, 0x2b, 0x1d, 0xb6, 0xf3, 0xcf, 0x33, 0xab, 0x17, +0x13, 0xb6, 0xfb, 0x76, 0x34, 0xeb, 0x03, 0xc4, 0xa1, 0x6e, 0x61, 0xb0, +0xc9, 0x43, 0x99, 0xb4, 0xe1, 0xc2, 0x15, 0x26, 0x7b, 0xc3, 0x30, 0xcf, +0x51, 0x5b, 0x0b, 0x01, 0x6d, 0x88, 0xc0, 0xd4, 0xb8, 0x08, 0x54, 0x1b, +0x5e, 0x32, 0x6d, 0xb6, 0xb3, 0xe6, 0x41, 0xc2, 0x44, 0x35, 0x37, 0xca, +0x01, 0xe2, 0x50, 0x71, 0x7e, 0x21, 0x0c, 0x1b, 0xc5, 0xce, 0x1f, 0x58, +0x0b, 0x04, 0x60, 0xee, 0x5c, 0x00, 0x5e, 0x51, 0xac, 0xda, 0x2e, 0x58, +0x94, 0x27, 0xfb, 0xce, 0x52, 0x57, 0x55, 0x6d, 0x24, 0xaa, 0x39, 0x2c, +0x07, 0x7d, 0x4c, 0xae, 0xd6, 0x73, 0x0b, 0x61, 0x88, 0x47, 0xfe, 0x5f, +0xc3, 0x49, 0x11, 0x6d, 0x31, 0x0b, 0xff, 0x6d, 0x60, 0x11, 0xa8, 0x2e, +0xff, 0xe0, 0xbd, 0xc3, 0xfb, 0x86, 0x27, 0xb3, 0xe4, 0xf8, 0x5c, 0x2b, +0x79, 0x08, 0xc2, 0x4c, 0x10, 0x0d, 0x6e, 0x73, 0x3b, 0x50, 0x02, 0xfa, +0x2c, 0xee, 0x2f, 0x93, 0x33, 0xf6, 0xb3, 0xf4, 0x3b, 0x50, 0xc4, 0xa0, +0xde, 0xfc, 0xc3, 0xf2, 0x24, 0xd4, 0x75, 0xcf, 0x11, 0xfa, 0xb2, 0x79, +0x08, 0xc2, 0x4c, 0x80, 0x38, 0x64, 0x0e, 0x1d, 0xd9, 0x12, 0xd0, 0xad, +0x84, 0x70, 0x8a, 0xbe, 0x3d, 0x1c, 0x7c, 0xaa, 0xdb, 0x03, 0xde, 0xb8, +0xde, 0x73, 0x0a, 0x84, 0xe3, 0x9e, 0x63, 0x9c, 0x12, 0x66, 0x82, 0xe8, +0xbb, 0x2e, 0xda, 0x67, 0x7c, 0x9c, 0x64, 0x47, 0x4f, 0x06, 0x6b, 0x82, +0x38, 0x61, 0x5c, 0x9b, 0x49, 0x5e, 0x6f, 0x78, 0x69, 0x2b, 0x8c, 0xa3, +0xed, 0xef, 0xdf, 0xc9, 0xb1, 0x09, 0xb3, 0x61, 0x26, 0xf9, 0x6f, 0xee, +0xa6, 0x86, 0x6a, 0xc4, 0xc1, 0x26, 0x69, 0x43, 0x0b, 0x2b, 0x6c, 0x72, +0x7b, 0x2c, 0x6b, 0x15, 0x43, 0x67, 0xbb, 0x87, 0xda, 0xb2, 0xd1, 0x94, +0x9d, 0x3e, 0x09, 0x2b, 0x55, 0x1f, 0x5e, 0x3a, 0x1a, 0xe3, 0x4f, 0xee, +0xe1, 0x58, 0x2f, 0x82, 0xb6, 0x1b, 0x70, 0x89, 0x58, 0xe2, 0x20, 0x0b, +0xee, 0xde, 0xba, 0xfe, 0x67, 0x5d, 0x38, 0xb7, 0x44, 0xe5, 0xac, 0xed, +0x39, 0x27, 0xb0, 0xf7, 0x73, 0x5a, 0x81, 0xcb, 0xb1, 0x10, 0xb1, 0xf3, +0x3b, 0xcc, 0xe4, 0xca, 0x87, 0x95, 0x5e, 0x92, 0x63, 0xec, 0xac, 0x9c, +0xaa, 0xe6, 0xd0, 0x1c, 0x1c, 0xdb, 0x6d, 0xc5, 0x28, 0x67, 0x95, 0xc1, +0xb7, 0xb6, 0xf0, 0xda, 0x43, 0x59, 0x5b, 0x16, 0x2e, 0xe4, 0xa9, 0x7a, +0xff, 0x9f, 0xb1, 0xf0, 0x50, 0x59, 0x45, 0x61, 0x0b, 0xa8, 0x20, 0xbc, +0xe4, 0xe7, 0xce, 0xad, 0xd6, 0xcf, 0x49, 0xb2, 0x1a, 0xae, 0x70, 0xbf, +0xea, 0x39, 0xd8, 0xb6, 0x11, 0xe1, 0xc2, 0xaa, 0x07, 0xb4, 0x56, 0x7a, +0xf2, 0x7c, 0x30, 0xdb, 0x9a, 0xd9, 0x5e, 0x51, 0x6a, 0xe3, 0xff, 0x61, +0x6f, 0xa0, 0xab, 0x77, 0x06, 0xe8, 0x67, 0x7e, 0xd6, 0x42, 0xba, 0xe4, +0xe5, 0x30, 0x7e, 0x77, 0xc9, 0x6e, 0xaf, 0xa0, 0x37, 0x9c, 0x23, 0xec, +0x97, 0xfa, 0xac, 0xd1, 0x46, 0xb2, 0x7a, 0x62, 0x94, 0xc0, 0x4b, 0x37, +0xfc, 0xaa, 0x8b, 0x2b, 0x83, 0x6d, 0x6d, 0xc1, 0x96, 0x45, 0xd6, 0x4f, +0x9e, 0x2b, 0x03, 0xf1, 0xe6, 0xff, 0xfd, 0x62, 0x85, 0x43, 0x4d, 0x73, +0x08, 0xaf, 0x42, 0x4b, 0xcf, 0x2e, 0x88, 0xa9, 0xb5, 0x5a, 0xcb, 0x7f, +0x2e, 0x26, 0x71, 0xc5, 0xe1, 0xa5, 0x98, 0xf1, 0xfc, 0xd4, 0x22, 0x41, +0xb2, 0x1a, 0x8e, 0x72, 0x39, 0x41, 0x66, 0x8f, 0xf3, 0x6f, 0x88, 0x43, +0xca, 0x64, 0x98, 0x1e, 0x0a, 0xbb, 0xfb, 0x9f, 0x65, 0x79, 0x62, 0x93, +0x5b, 0xe9, 0x22, 0x5a, 0xeb, 0x29, 0xf1, 0x95, 0x43, 0x56, 0x50, 0x67, +0x78, 0x29, 0xaa, 0x80, 0xa7, 0x1c, 0x8f, 0x94, 0xbc, 0x42, 0xd6, 0x09, +0xb4, 0x25, 0x0e, 0xf2, 0xfb, 0x0d, 0x55, 0xdb, 0x54, 0x77, 0x52, 0x9c, +0x32, 0xd6, 0xeb, 0x1b, 0x87, 0x4c, 0x5e, 0x61, 0x92, 0xbc, 0x50, 0x4a, +0x91, 0x08, 0x1b, 0xf8, 0xe1, 0x45, 0x40, 0x56, 0x71, 0xc8, 0xe4, 0x39, +0xb4, 0xb8, 0x98, 0x50, 0xc6, 0xda, 0x91, 0xe8, 0xa7, 0x4e, 0xf2, 0xa6, +0x14, 0x09, 0x1b, 0x0e, 0xc6, 0x53, 0x85, 0x6c, 0x61, 0x25, 0xd9, 0x91, +0xb4, 0xb8, 0xc0, 0xd5, 0x22, 0x10, 0xec, 0xe6, 0xe2, 0x90, 0x29, 0x39, +0x9d, 0x7a, 0x51, 0x4d, 0x76, 0x58, 0xd5, 0x86, 0x9a, 0xe8, 0xcf, 0x04, +0x51, 0x3d, 0x87, 0x30, 0x8e, 0xb9, 0xd2, 0xba, 0xfa, 0xce, 0x82, 0x42, +0x19, 0x6b, 0x41, 0xa6, 0x0c, 0xef, 0x2a, 0x57, 0x55, 0x59, 0xb2, 0x76, +0x37, 0x36, 0x61, 0x8d, 0x17, 0x01, 0x51, 0x92, 0xb1, 0x5b, 0xd5, 0x4a, +0xe6, 0x74, 0xe6, 0x34, 0xaa, 0x70, 0x22, 0x0e, 0x75, 0x90, 0xba, 0xe8, +0xa0, 0x80, 0x97, 0x37, 0xa5, 0x10, 0x89, 0xd0, 0x8b, 0xc0, 0x7b, 0x1d, +0x78, 0x47, 0x15, 0x63, 0x80, 0x3d, 0x13, 0x07, 0x5f, 0x0d, 0xd1, 0x72, +0xad, 0x7e, 0x31, 0x81, 0x60, 0x62, 0xc6, 0xdd, 0x71, 0xbb, 0x86, 0xf3, +0x0e, 0xb9, 0xbd, 0x22, 0x9b, 0xb0, 0xe6, 0x5c, 0xc4, 0x98, 0xcc, 0x29, +0xc5, 0xc1, 0x84, 0x95, 0x5a, 0x3f, 0xc8, 0x55, 0x4a, 0x20, 0xf0, 0x1c, +0x1a, 0xf1, 0x1e, 0x2a, 0xa8, 0x2c, 0x4b, 0x92, 0x78, 0xd7, 0x79, 0x8d, +0x17, 0x31, 0x1e, 0x51, 0x16, 0xbd, 0x67, 0x87, 0xe0, 0x7a, 0x39, 0xc8, +0x55, 0xe2, 0x2c, 0x04, 0x93, 0x31, 0xbe, 0xf7, 0x90, 0x2a, 0x5e, 0x5f, +0x51, 0xd9, 0x71, 0x74, 0x4f, 0xc2, 0x86, 0x9a, 0xf0, 0x22, 0xd8, 0x49, +0x45, 0xe9, 0xab, 0xd4, 0xd8, 0x39, 0x87, 0x97, 0xe4, 0x4e, 0x52, 0xd3, +0x4d, 0xb3, 0x1d, 0x91, 0xaf, 0x70, 0x9c, 0x47, 0xf7, 0x24, 0xb4, 0x2a, +0x11, 0x2f, 0x82, 0x89, 0x72, 0xc9, 0x73, 0xd0, 0xbe, 0x4a, 0xbd, 0x85, +0x46, 0x0a, 0x54, 0x31, 0xd1, 0x5b, 0xa9, 0xf2, 0x9d, 0x75, 0xe5, 0xef, +0x2a, 0xba, 0x48, 0x68, 0x55, 0x13, 0x5e, 0x44, 0xbf, 0xdc, 0x62, 0x7a, +0x0e, 0x4f, 0xbc, 0x86, 0xee, 0x06, 0x4f, 0x4e, 0x81, 0xa0, 0x8b, 0x66, +0x3b, 0xef, 0xaf, 0xf2, 0x77, 0x35, 0xc7, 0x0e, 0xa9, 0x69, 0xc3, 0x4a, +0xbc, 0x88, 0xfe, 0xb8, 0xc7, 0xbc, 0xc7, 0x61, 0xa3, 0x4a, 0x69, 0xe9, +0x38, 0x2c, 0x92, 0x2d, 0x49, 0x8d, 0x40, 0x34, 0xe5, 0x3d, 0xd4, 0xbe, +0x19, 0x8a, 0x5a, 0x02, 0xab, 0x73, 0x1f, 0x2f, 0xa2, 0xb3, 0x09, 0x12, +0x6b, 0x90, 0xd8, 0xb2, 0xb7, 0x8e, 0x4a, 0x58, 0x8b, 0xb8, 0xec, 0xee, +0x79, 0xfe, 0x01, 0x22, 0x6d, 0x8c, 0x12, 0x9e, 0x82, 0x5f, 0x46, 0x9b, +0xff, 0xba, 0x06, 0xb4, 0xda, 0x11, 0x01, 0x12, 0xb9, 0x99, 0xf2, 0x35, +0xc2, 0xbb, 0x1c, 0x02, 0xcf, 0xa1, 0xfb, 0x85, 0xc6, 0x91, 0x83, 0x68, +0x8e, 0x54, 0x89, 0xe9, 0x06, 0x8b, 0x08, 0xa2, 0x7a, 0x51, 0xda, 0x22, +0x9f, 0x50, 0x13, 0xae, 0xf5, 0x6a, 0x32, 0x7a, 0x30, 0x71, 0x78, 0x90, +0xb3, 0x1f, 0x13, 0x55, 0x4c, 0xd5, 0x8b, 0x7a, 0x8b, 0x02, 0x1e, 0xd5, +0x0b, 0x36, 0x05, 0x29, 0x6c, 0x66, 0x46, 0x75, 0xad, 0xd7, 0x92, 0xd1, +0xe6, 0xf0, 0xdb, 0x84, 0xe0, 0x72, 0x48, 0x6e, 0x34, 0xef, 0xa1, 0xf1, +0xd0, 0x4a, 0xb4, 0x5c, 0x9a, 0x5e, 0xc2, 0x45, 0xa8, 0x69, 0xc0, 0xc9, +0xb1, 0x16, 0x52, 0x1a, 0x5c, 0x1c, 0xa2, 0x4f, 0xb0, 0x9d, 0x5e, 0x04, +0x0d, 0xd2, 0xea, 0x13, 0xf3, 0x69, 0xe4, 0xb5, 0x21, 0x14, 0x09, 0xd9, +0x44, 0x12, 0x6a, 0x1a, 0xc8, 0x95, 0xdc, 0xd1, 0x36, 0x63, 0x1a, 0xfd, +0xf9, 0xe6, 0x2a, 0x7b, 0x65, 0xe2, 0x1d, 0xe6, 0x71, 0xfd, 0x2c, 0x89, +0xe9, 0xbc, 0x22, 0x31, 0x5a, 0xb8, 0xb9, 0xe9, 0x09, 0x72, 0x65, 0x72, +0xac, 0x85, 0x94, 0x44, 0x2c, 0x7a, 0x3e, 0xe3, 0xd0, 0x80, 0x37, 0x41, +0x8c, 0xf7, 0x23, 0x77, 0x3f, 0x0e, 0xe7, 0xb5, 0xfb, 0xc7, 0x11, 0xeb, +0x32, 0xe1, 0x26, 0x44, 0xa2, 0xe3, 0x9d, 0xc1, 0x56, 0x48, 0xc9, 0xf4, +0x53, 0xe2, 0xc5, 0x27, 0xf0, 0xd6, 0x46, 0x09, 0x6b, 0x44, 0xf2, 0x0c, +0xe6, 0xd4, 0x22, 0xe0, 0xc6, 0xcb, 0x07, 0x21, 0x12, 0x83, 0x4d, 0xa2, +0xa8, 0x2d, 0x33, 0xbc, 0xe0, 0x10, 0x07, 0x7f, 0xce, 0x94, 0x7a, 0xd1, +0x1a, 0xfc, 0xf0, 0xdc, 0x54, 0xf8, 0x46, 0xbf, 0xde, 0x17, 0xbc, 0x68, +0x22, 0x21, 0x1b, 0x4a, 0x2a, 0x9b, 0x3a, 0x0a, 0x2f, 0xad, 0x9d, 0x8a, +0x96, 0xdf, 0x23, 0xd7, 0x50, 0xe5, 0x22, 0x36, 0xda, 0xce, 0xec, 0x56, +0xa2, 0x8b, 0xae, 0x1b, 0x33, 0x07, 0x14, 0x45, 0x24, 0x34, 0x12, 0xc1, +0x49, 0xeb, 0x4a, 0xd9, 0x9b, 0x3c, 0x95, 0x17, 0x18, 0x86, 0x94, 0x8c, +0x30, 0xcc, 0x8e, 0xb2, 0xb5, 0x33, 0xdc, 0x33, 0x24, 0xaf, 0x47, 0xd9, +0x99, 0xdd, 0x2b, 0xb8, 0x07, 0x7c, 0x61, 0xed, 0x38, 0x17, 0x91, 0x30, +0x27, 0xad, 0x89, 0x3e, 0x54, 0xc6, 0xcb, 0x98, 0xb8, 0x6d, 0x97, 0x21, +0x1e, 0x43, 0x90, 0x67, 0x40, 0x18, 0x32, 0x7b, 0x71, 0x8e, 0x03, 0x74, +0x9f, 0x9e, 0x61, 0x05, 0x77, 0x80, 0x8f, 0x18, 0x22, 0xb9, 0x25, 0x12, +0x09, 0xd6, 0x94, 0x16, 0x16, 0x28, 0x7b, 0x77, 0x83, 0xc6, 0x0a, 0xfd, +0x0b, 0x9c, 0x51, 0xfa, 0x76, 0xc2, 0x4d, 0x9d, 0x87, 0x3d, 0x8a, 0x8a, +0x03, 0x95, 0x7a, 0x71, 0x3b, 0x3e, 0xd3, 0x8e, 0xa3, 0x4e, 0x16, 0xdd, +0x6d, 0x6a, 0x65, 0x81, 0xbe, 0x2c, 0xf9, 0xd5, 0x54, 0x1a, 0x4c, 0xa8, +0x7b, 0x9b, 0x22, 0xd1, 0xf1, 0x22, 0x36, 0xb9, 0x72, 0xb9, 0x06, 0x12, +0xab, 0x91, 0x45, 0x5a, 0xd7, 0x1c, 0x47, 0x65, 0x53, 0x7d, 0x22, 0x21, +0x2f, 0x59, 0x05, 0xc2, 0xbf, 0xf0, 0x05, 0x6f, 0xa1, 0x8f, 0xdd, 0xb0, +0x79, 0x9f, 0xbd, 0x09, 0x45, 0x36, 0x81, 0x30, 0x61, 0xd5, 0x89, 0xa1, +0xfa, 0x89, 0x68, 0x39, 0xa0, 0x60, 0x53, 0x0a, 0xb5, 0x2d, 0x52, 0x78, +0x09, 0x7d, 0xb8, 0xec, 0x3b, 0xc4, 0xa2, 0x07, 0xe1, 0x9f, 0x52, 0x3e, +0x27, 0xff, 0x2e, 0xf0, 0x9e, 0x33, 0xbf, 0x0b, 0x23, 0x12, 0x78, 0x69, +0x00, 0x21, 0x39, 0xe2, 0xea, 0xb2, 0xe3, 0xf3, 0x0b, 0x60, 0xcb, 0x3b, +0xe2, 0x28, 0x5e, 0x97, 0x79, 0x16, 0x78, 0xcd, 0xd7, 0x48, 0x71, 0x10, +0x14, 0x91, 0x00, 0x58, 0x61, 0xc9, 0x55, 0xba, 0x69, 0x62, 0xea, 0x2d, +0x2e, 0x8c, 0xbb, 0xcb, 0x85, 0xe5, 0x79, 0x06, 0x9e, 0x81, 0xfe, 0xcc, +0x78, 0x07, 0x15, 0x8b, 0x44, 0xf0, 0xbe, 0x26, 0x3c, 0x3a, 0x00, 0xef, +0xb6, 0xe7, 0xac, 0xd2, 0x69, 0xbc, 0x7c, 0x79, 0xb1, 0xbd, 0x96, 0xe4, +0xbf, 0x57, 0x16, 0x16, 0x16, 0x95, 0x76, 0x3d, 0x89, 0x4f, 0x63, 0xd5, +0x8c, 0x57, 0x3c, 0x3e, 0x18, 0x96, 0xec, 0x27, 0x84, 0xb9, 0xe7, 0x1a, +0x5a, 0x10, 0x09, 0xc7, 0x7d, 0x28, 0x00, 0x7f, 0x77, 0xc8, 0x99, 0x4f, +0x0b, 0x13, 0xfb, 0x05, 0x44, 0x02, 0xa0, 0x21, 0x72, 0x37, 0xa2, 0xc3, +0x75, 0x87, 0xd6, 0x44, 0x82, 0x8d, 0x0d, 0x0c, 0xcd, 0x3d, 0x63, 0x5e, +0x82, 0x1d, 0x19, 0x44, 0xf1, 0x7e, 0x1d, 0xe1, 0x51, 0x80, 0x6c, 0x64, +0xc9, 0x4b, 0x78, 0x6f, 0x05, 0xa0, 0x19, 0x91, 0x18, 0xa4, 0xff, 0x18, +0x40, 0xf9, 0x49, 0xc7, 0x64, 0x83, 0x46, 0x3d, 0x89, 0x89, 0x47, 0x0d, +0xf0, 0x2f, 0x73, 0xaa, 0xbc, 0x04, 0x02, 0x01, 0x2d, 0x8d, 0x57, 0x04, +0x02, 0x60, 0x9d, 0x09, 0x81, 0x80, 0x96, 0xc6, 0x6b, 0x62, 0x91, 0xa0, +0xb8, 0x02, 0x20, 0xf5, 0xa4, 0x43, 0x20, 0x20, 0x21, 0x49, 0x8a, 0x2d, +0x68, 0x17, 0x0e, 0xf0, 0x64, 0xd2, 0x5d, 0x15, 0x09, 0x3d, 0xa1, 0xaa, +0x6d, 0x29, 0x10, 0x08, 0x48, 0x48, 0x8a, 0x0e, 0xc6, 0x78, 0x0f, 0x00, +0x4f, 0x78, 0x59, 0x77, 0xbe, 0xd2, 0x93, 0xc8, 0xb6, 0xa3, 0xd0, 0xde, +0x44, 0x08, 0x03, 0x64, 0x11, 0x09, 0xad, 0xc8, 0xbb, 0xb2, 0xb9, 0x31, +0xd7, 0x1f, 0x03, 0xc0, 0x0b, 0x16, 0x15, 0x81, 0xe0, 0x6e, 0x8f, 0xc9, +0xd1, 0x93, 0x08, 0xea, 0x64, 0x32, 0x63, 0x54, 0x7e, 0x7d, 0xef, 0xad, +0x65, 0xbd, 0xda, 0xd0, 0xcc, 0x26, 0x07, 0xcf, 0x01, 0xe0, 0xc8, 0xce, +0x8c, 0x47, 0x00, 0x1d, 0x8d, 0xe5, 0x2d, 0x03, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0xa8, 0x83, 0x9b, 0x37, 0x00, 0x00, 0x80, 0x0f, 0xcc, 0x7f, +0x6c, 0xe2, 0x31, 0x00, 0x00, 0xc0, 0x07, 0xbe, 0x7c, 0xf9, 0xf2, 0xdf, +0x3f, 0xbf, 0xdc, 0x79, 0x12, 0x00, 0x00, 0x60, 0x59, 0xbe, 0x7e, 0xfd, +0xfa, 0x1f, 0x1e, 0x03, 0x00, 0x00, 0x58, 0xc4, 0x6b, 0x78, 0x43, 0x20, +0x00, 0x00, 0xc0, 0x32, 0x7d, 0xfb, 0xf6, 0xed, 0x7f, 0x22, 0x10, 0xe2, +0x45, 0xf0, 0x38, 0x00, 0x00, 0xe0, 0xe6, 0x05, 0xe1, 0xcd, 0x18, 0xf9, +0x07, 0x00, 0x80, 0xd1, 0xbd, 0x06, 0x9f, 0x90, 0x7e, 0x43, 0x20, 0x00, +0x00, 0x40, 0x16, 0xff, 0x79, 0x43, 0x18, 0xde, 0x7c, 0x98, 0x89, 0x33, +0x10, 0x00, 0x00, 0x83, 0x09, 0xc3, 0x62, 0xf2, 0x0c, 0xab, 0x46, 0x82, +0x1a, 0x00, 0x60, 0x1c, 0x26, 0xbf, 0xe8, 0xbf, 0xed, 0xb4, 0x99, 0x47, +0x06, 0x00, 0xd0, 0xb9, 0x30, 0x6c, 0x85, 0x91, 0x5e, 0x18, 0xf9, 0x07, +0x00, 0x80, 0x4e, 0x99, 0x4f, 0x0a, 0xc3, 0x9b, 0xff, 0x77, 0x00, 0x00, +0xd0, 0x19, 0xf7, 0xb3, 0xc2, 0xe0, 0x08, 0x2f, 0x01, 0x00, 0xf4, 0xeb, +0x35, 0xbc, 0x4a, 0x3e, 0xbf, 0x32, 0xaa, 0x97, 0x00, 0x00, 0x3a, 0xf3, +0x1a, 0x0e, 0x26, 0xa0, 0x9f, 0x59, 0xca, 0xd3, 0xd3, 0x08, 0x0f, 0x00, +0x40, 0x4b, 0x5e, 0x43, 0x60, 0x53, 0xc2, 0xcf, 0x3a, 0x39, 0xda, 0x77, +0x00, 0x00, 0x24, 0xe7, 0xd1, 0x1a, 0xe3, 0xfb, 0xf7, 0xef, 0xff, 0xc4, +0x12, 0x87, 0xc4, 0xe1, 0x25, 0xad, 0xa6, 0x22, 0xbf, 0x01, 0x00, 0x90, +0x90, 0x47, 0x22, 0x7a, 0x59, 0x96, 0xb7, 0x1f, 0x3f, 0x7e, 0x44, 0x13, +0x88, 0x1d, 0x8b, 0xf7, 0x6d, 0xc3, 0xb6, 0xfe, 0x8e, 0x7c, 0xbd, 0x47, +0xdb, 0x70, 0x2f, 0x3e, 0x13, 0xaf, 0x0e, 0x00, 0x20, 0xb1, 0x38, 0xfc, +0xfc, 0xf9, 0xf3, 0x4d, 0x2c, 0x96, 0x38, 0x88, 0x27, 0xe2, 0xc5, 0xc6, +0x8a, 0xc4, 0xa3, 0x1d, 0x87, 0x2e, 0xf0, 0x5b, 0x26, 0x9f, 0x47, 0xcd, +0xfe, 0xbe, 0xe3, 0x64, 0x36, 0x00, 0x40, 0x36, 0x6e, 0xb2, 0x08, 0xff, +0xfa, 0xf5, 0x2b, 0xba, 0x38, 0xc8, 0xd7, 0xfc, 0xfd, 0xfb, 0xb7, 0x7e, +0xdd, 0xc5, 0x0b, 0xc5, 0x9b, 0xcb, 0xe7, 0x9d, 0x00, 0x00, 0xc0, 0x59, +0x71, 0x90, 0x5d, 0xb8, 0x2c, 0xe0, 0xb2, 0x98, 0xc7, 0x4c, 0x4c, 0xcb, +0xd7, 0x12, 0x91, 0x90, 0x90, 0x95, 0x0a, 0x85, 0xfc, 0x77, 0xe4, 0xe4, +0x37, 0x27, 0xb3, 0x01, 0x00, 0x52, 0xa0, 0x61, 0x25, 0x59, 0xbc, 0x63, +0x26, 0xa6, 0xd7, 0x4c, 0xc4, 0x41, 0xbe, 0x4f, 0x44, 0x21, 0xa2, 0x72, +0x09, 0x00, 0x20, 0x11, 0x8b, 0x2e, 0xda, 0xf2, 0x6b, 0x4a, 0x71, 0x50, +0x93, 0x7c, 0x84, 0x09, 0x39, 0x9d, 0x36, 0x72, 0x0f, 0x00, 0x00, 0xe9, +0x98, 0x6c, 0x8e, 0x20, 0xb5, 0xf7, 0xb0, 0x26, 0x12, 0x67, 0x2b, 0xa5, +0xbc, 0xf7, 0x41, 0x68, 0x09, 0x00, 0x20, 0x05, 0x36, 0xb4, 0x94, 0xcb, +0x7b, 0x88, 0x28, 0x12, 0x24, 0xa6, 0x01, 0x00, 0x52, 0x20, 0xe1, 0x19, +0x5d, 0xa0, 0x63, 0x27, 0xa6, 0xdd, 0x89, 0x9c, 0xc4, 0xc1, 0xef, 0x4f, +0xde, 0x01, 0x00, 0x20, 0x11, 0xb3, 0x84, 0x93, 0x64, 0x61, 0xce, 0x1d, +0x5a, 0xda, 0x12, 0x89, 0xbd, 0x1e, 0x0c, 0xed, 0xc2, 0x01, 0x00, 0xd2, +0x31, 0xc9, 0x6e, 0x5d, 0xf3, 0x0e, 0x91, 0x4f, 0x4b, 0x5f, 0x12, 0x89, +0x57, 0x42, 0xe5, 0xc5, 0x81, 0xa6, 0x7c, 0x00, 0x00, 0x09, 0xb8, 0x5b, +0x71, 0x28, 0x91, 0x77, 0x70, 0x4f, 0x92, 0xce, 0xcf, 0xc4, 0x0a, 0x71, +0x00, 0x00, 0x48, 0xc7, 0xa2, 0x27, 0xa5, 0x6b, 0x13, 0x07, 0x2b, 0x12, +0x61, 0x2e, 0xc2, 0xff, 0x3f, 0x09, 0x69, 0x00, 0x80, 0xc8, 0x3c, 0x9a, +0xda, 0x89, 0x30, 0xc8, 0xee, 0xbc, 0xb6, 0xb0, 0x92, 0xdb, 0x2e, 0x5f, +0x9d, 0xbd, 0x4d, 0x78, 0x0d, 0x00, 0x00, 0xf1, 0x78, 0x6f, 0x82, 0xa7, +0x5d, 0x59, 0xb5, 0x85, 0xc6, 0x9e, 0x38, 0x7f, 0x25, 0x36, 0xf1, 0x1a, +0x01, 0x00, 0x22, 0x7a, 0x0a, 0x22, 0x0a, 0xda, 0x39, 0x55, 0x45, 0x41, +0x7e, 0xad, 0xd9, 0x63, 0x70, 0x9c, 0x90, 0x06, 0x00, 0x48, 0xc2, 0xbb, +0x28, 0xa8, 0x30, 0x58, 0x2b, 0x75, 0xb6, 0xc1, 0xed, 0xec, 0xf2, 0xfa, +0xc2, 0x9b, 0xe1, 0x94, 0x34, 0x00, 0xc0, 0x19, 0x6f, 0x41, 0xc2, 0x47, +0xba, 0xc8, 0x8a, 0xd5, 0x2c, 0x06, 0x6b, 0xb6, 0xc3, 0xb3, 0xe1, 0x30, +0x1c, 0x00, 0xc0, 0x01, 0x26, 0x15, 0x82, 0xb5, 0x8a, 0x9f, 0xda, 0xcd, +0x7a, 0x0c, 0x9a, 0x13, 0x71, 0x1c, 0x88, 0x03, 0x00, 0xb8, 0x4c, 0xec, +0x4b, 0x76, 0xb2, 0x1f, 0x84, 0x13, 0x51, 0xb0, 0x02, 0xf1, 0xac, 0x9b, +0x2b, 0x02, 0x01, 0x00, 0xf0, 0x9c, 0x47, 0x45, 0x92, 0x5f, 0x2c, 0x9b, +0x16, 0x07, 0x6d, 0xeb, 0xa1, 0x5e, 0x8f, 0x96, 0xdc, 0xbe, 0xf0, 0x82, +0x26, 0x86, 0x00, 0x00, 0x40, 0x20, 0x0a, 0xbe, 0x92, 0xe7, 0xad, 0x75, +0xb3, 0xe2, 0xa0, 0x1e, 0xc4, 0x81, 0x3e, 0x50, 0xe4, 0x21, 0x00, 0x00, +0x44, 0x18, 0x7a, 0x11, 0x05, 0x67, 0xda, 0x79, 0x5b, 0x81, 0xd0, 0x90, +0x92, 0x76, 0x91, 0x7d, 0x75, 0x68, 0x8f, 0x72, 0x57, 0x00, 0x18, 0x91, +0x9b, 0xf7, 0x14, 0xee, 0x3e, 0x8c, 0xb2, 0xf4, 0x24, 0x0c, 0x56, 0x04, +0x44, 0x20, 0xf4, 0x5c, 0x86, 0x86, 0x93, 0xac, 0x68, 0xec, 0xe8, 0xbf, +0x04, 0x00, 0x4f, 0x16, 0x92, 0xd0, 0xa6, 0x17, 0x46, 0xfd, 0x78, 0x7d, +0xef, 0xf0, 0x21, 0x02, 0x7a, 0x07, 0x83, 0xee, 0xac, 0xf5, 0x30, 0x9b, +0x58, 0xed, 0xe7, 0x16, 0xae, 0x86, 0x95, 0xb6, 0xfe, 0x7c, 0x47, 0x4f, +0x28, 0xc6, 0x33, 0x0c, 0xbb, 0x68, 0xcc, 0xba, 0x70, 0xc8, 0x6e, 0x29, +0x34, 0x2d, 0x65, 0xb4, 0x66, 0x5d, 0x77, 0x59, 0x60, 0xb4, 0x97, 0x7e, +0x78, 0x48, 0x4a, 0x4d, 0xbe, 0x8e, 0x77, 0xd5, 0x17, 0x6f, 0x93, 0xa3, +0xbf, 0x4d, 0xb2, 0x30, 0x91, 0x7d, 0xa7, 0xf6, 0x44, 0xb3, 0x2e, 0x88, +0xba, 0x68, 0xea, 0x39, 0x80, 0xf0, 0x80, 0x5b, 0x23, 0xad, 0x30, 0x9e, +0x5a, 0xf8, 0xf3, 0x86, 0x22, 0x70, 0x50, 0x20, 0x68, 0xd4, 0x07, 0xe3, +0xec, 0x22, 0x75, 0xe1, 0x77, 0x11, 0x9a, 0x9a, 0xe9, 0xe2, 0xa2, 0x62, +0x61, 0x27, 0x65, 0x68, 0xba, 0x53, 0x55, 0x51, 0x91, 0x7f, 0x67, 0x84, +0x63, 0x46, 0x34, 0xce, 0xbf, 0x57, 0x15, 0x03, 0x2d, 0xe5, 0x0c, 0x17, +0x48, 0x2b, 0x06, 0xbd, 0x78, 0x09, 0xee, 0xc5, 0x21, 0xb8, 0x70, 0xfc, +0xd9, 0x50, 0x92, 0xfd, 0xf3, 0x57, 0x02, 0x41, 0x1e, 0x02, 0xba, 0xdd, +0x49, 0xaa, 0x67, 0x90, 0x6b, 0x51, 0xb0, 0x2d, 0x17, 0x5e, 0x09, 0x46, +0x28, 0x1c, 0x1b, 0xa2, 0x81, 0xb7, 0xf1, 0x22, 0x5c, 0xb4, 0xe6, 0x21, +0xa8, 0x28, 0x8c, 0x22, 0x08, 0xee, 0x49, 0x0e, 0x22, 0x7c, 0x26, 0xd6, +0x7b, 0x38, 0xd0, 0x76, 0x9c, 0x30, 0x13, 0x34, 0x2f, 0x08, 0x8b, 0x0d, +0x0b, 0xb9, 0x4a, 0x5a, 0x27, 0x5b, 0x2f, 0x63, 0x6d, 0x21, 0x3b, 0xe2, +0x6d, 0x18, 0xf1, 0xe8, 0x59, 0x38, 0x34, 0x81, 0x3c, 0x85, 0xe1, 0x22, +0x9b, 0x37, 0x58, 0x7b, 0x66, 0x2a, 0x0a, 0x3d, 0x84, 0x89, 0x62, 0x8e, +0xbf, 0x30, 0xdf, 0x62, 0xc7, 0xd6, 0x9e, 0xb9, 0xc2, 0x65, 0x41, 0xd0, +0x22, 0x93, 0x7a, 0x08, 0x2d, 0x4e, 0xda, 0xb5, 0x64, 0xe9, 0x1e, 0xe1, +0x90, 0xbf, 0x6b, 0x85, 0xc3, 0xfd, 0xcd, 0x6d, 0x58, 0x8f, 0xe3, 0x56, +0xd9, 0x82, 0x6f, 0x17, 0xfd, 0xf7, 0x85, 0xdf, 0x9a, 0x7d, 0x1e, 0xfa, +0x4c, 0x5e, 0x3d, 0x17, 0xeb, 0x79, 0x21, 0x08, 0x69, 0x0d, 0x91, 0x80, +0xa6, 0xc2, 0x46, 0x3d, 0xef, 0xf8, 0xd6, 0x16, 0xcb, 0x57, 0x0b, 0xa5, +0x15, 0x8e, 0x95, 0x70, 0x55, 0x68, 0xb3, 0x5b, 0xaf, 0xbe, 0x0a, 0x2b, +0xb6, 0x9e, 0x2d, 0xf8, 0xb7, 0x23, 0x0b, 0xbe, 0x5d, 0xf4, 0xf7, 0x2c, +0xfe, 0x5b, 0x66, 0xf3, 0x09, 0x2c, 0xdc, 0x88, 0x04, 0x10, 0x73, 0x7e, +0x84, 0x18, 0x46, 0x8d, 0x25, 0x3f, 0x0b, 0x59, 0x85, 0xa1, 0x83, 0xbd, +0x61, 0xab, 0x35, 0xb3, 0x0b, 0xf9, 0x56, 0x65, 0x56, 0xf8, 0xe7, 0x31, +0x16, 0xfc, 0x3d, 0x1e, 0x93, 0x7e, 0x16, 0x44, 0xa1, 0x1a, 0x91, 0x20, +0x27, 0x01, 0x45, 0x45, 0x61, 0x46, 0x14, 0xce, 0xdf, 0x29, 0xbc, 0xe6, +0x85, 0xec, 0x11, 0x91, 0x92, 0x66, 0xc3, 0x45, 0x88, 0x41, 0xfd, 0xe3, +0xcc, 0xd1, 0x86, 0x03, 0x4a, 0xe4, 0x14, 0x10, 0x85, 0x32, 0x5e, 0x48, +0x0a, 0x0f, 0x60, 0x4f, 0x0e, 0x65, 0xe4, 0x4a, 0xa3, 0x0e, 0x8c, 0x33, +0x12, 0x90, 0x27, 0x8c, 0xc4, 0x64, 0xab, 0xdf, 0x0b, 0x39, 0x6a, 0xd6, +0x1b, 0x40, 0x04, 0xba, 0x34, 0xbc, 0x08, 0x48, 0x2b, 0x0c, 0x2c, 0x1c, +0x18, 0x86, 0x07, 0x01, 0xf0, 0x21, 0xc7, 0x80, 0x30, 0x60, 0x58, 0xdb, +0xc6, 0x29, 0x6b, 0x88, 0x4d, 0x34, 0x61, 0xd0, 0xb0, 0x45, 0x8b, 0x57, +0x3f, 0x62, 0x18, 0x02, 0x01, 0xf0, 0x97, 0x29, 0xd6, 0xd9, 0x05, 0x1b, +0x1b, 0x47, 0x1c, 0x30, 0x8c, 0x1c, 0x04, 0x20, 0x0c, 0x0f, 0x61, 0x38, +0xd2, 0x1e, 0x00, 0xc3, 0xb0, 0xe4, 0x36, 0xb1, 0xc4, 0xc1, 0x19, 0xee, +0x31, 0x4f, 0x3b, 0x6b, 0x29, 0x26, 0xb5, 0xf1, 0x18, 0x46, 0x78, 0x09, +0xda, 0x4e, 0x40, 0x47, 0xab, 0x4c, 0x92, 0xaf, 0xa3, 0xb5, 0xf3, 0x4c, +0x4a, 0x0c, 0xc3, 0x7b, 0x00, 0xc2, 0x49, 0xef, 0x21, 0x25, 0xc4, 0x01, +0xc3, 0xc8, 0x3d, 0x40, 0xfb, 0x44, 0x2d, 0x5b, 0xb5, 0xf7, 0xe9, 0x32, +0x19, 0x31, 0xac, 0xba, 0x36, 0x1b, 0x34, 0xec, 0x83, 0x7d, 0xb9, 0x06, +0x1f, 0x8b, 0x8c, 0x7e, 0x9f, 0x2e, 0x2d, 0x9c, 0x31, 0x8c, 0xc3, 0x71, +0xd0, 0x2e, 0xd1, 0x4f, 0x41, 0xab, 0x38, 0x10, 0x56, 0xc2, 0x30, 0x12, +0xd3, 0x80, 0xd7, 0xf0, 0x21, 0xe7, 0xa0, 0x0d, 0xdd, 0xa8, 0x56, 0xc2, +0x30, 0xee, 0x82, 0x00, 0xbc, 0x86, 0x0f, 0xd5, 0x4a, 0xe4, 0x1d, 0x30, +0xac, 0xda, 0xbc, 0x03, 0x77, 0x40, 0x40, 0x5e, 0xaf, 0x21, 0x0c, 0x2d, +0x89, 0x48, 0x70, 0x08, 0x0e, 0xc3, 0xc8, 0x3b, 0x40, 0x3b, 0x24, 0x6f, +0xac, 0xa7, 0xde, 0x03, 0x89, 0x69, 0x0c, 0xab, 0xce, 0x73, 0x40, 0x1c, +0x20, 0xbf, 0xd7, 0xe0, 0x82, 0x92, 0x56, 0x31, 0x72, 0x0f, 0x18, 0x56, +0x8d, 0x30, 0x2c, 0x84, 0x95, 0x60, 0x55, 0x18, 0xfc, 0xe0, 0x48, 0x1a, +0xee, 0x91, 0xa4, 0x97, 0x7c, 0x7d, 0xa9, 0x58, 0x22, 0xf7, 0x80, 0x61, +0xe5, 0x45, 0xc1, 0x6f, 0x08, 0x67, 0x92, 0xd1, 0xb0, 0x46, 0xce, 0x0b, +0x7c, 0x44, 0x80, 0x6e, 0x36, 0x39, 0x8d, 0xf7, 0x80, 0xf5, 0x68, 0xa9, +0x6f, 0xd3, 0x93, 0xaf, 0x2d, 0x9b, 0xad, 0xd0, 0xb4, 0xd3, 0xf1, 0xda, +0x9f, 0x79, 0x21, 0x58, 0xbc, 0x89, 0x20, 0x4c, 0x2c, 0x7f, 0xf0, 0xd4, +0x63, 0xc8, 0x21, 0x0c, 0xbe, 0x54, 0x4e, 0x07, 0xe3, 0xa4, 0xa5, 0xad, +0x9c, 0x7b, 0xc0, 0x7a, 0xde, 0x99, 0xa7, 0xca, 0xad, 0xf9, 0x85, 0xfe, +0xfe, 0x64, 0xc3, 0x87, 0x27, 0x00, 0x75, 0xe7, 0x18, 0x9e, 0x24, 0xbb, +0x16, 0xcd, 0x3f, 0x90, 0x9c, 0xc6, 0x7a, 0x36, 0xbd, 0x97, 0x9b, 0xe4, +0x31, 0x34, 0x13, 0x4a, 0xca, 0x35, 0x39, 0xb6, 0x0e, 0xd8, 0x88, 0x38, +0xd1, 0x56, 0x03, 0x1b, 0x25, 0xcc, 0x14, 0x4b, 0x20, 0xbc, 0x38, 0x10, +0x12, 0x82, 0x24, 0x44, 0xed, 0xb8, 0xba, 0x33, 0xd7, 0xb0, 0x8a, 0x7c, +0x0e, 0x15, 0x08, 0xce, 0x3e, 0x60, 0x08, 0x04, 0x6d, 0xb6, 0x61, 0x10, +0x61, 0xd8, 0xb3, 0xcb, 0x91, 0xcf, 0xa3, 0x09, 0x6a, 0x16, 0x11, 0xac, +0x77, 0x81, 0x88, 0xe4, 0x25, 0x23, 0x0e, 0x10, 0x37, 0x94, 0x94, 0xd9, +0x63, 0xd0, 0x90, 0xd2, 0xcb, 0xfa, 0x69, 0x15, 0x08, 0x12, 0xd4, 0x18, +0x02, 0x41, 0x58, 0x09, 0xf2, 0xf1, 0x48, 0x3e, 0x17, 0x0a, 0xdb, 0x2c, +0x6e, 0x67, 0xe5, 0x84, 0x0a, 0x04, 0xe7, 0x1f, 0xb0, 0x11, 0x04, 0xe2, +0xec, 0x38, 0x47, 0x1c, 0x20, 0x5a, 0x18, 0xa9, 0x94, 0x30, 0x9c, 0xa8, +0xaa, 0x78, 0x3f, 0x03, 0x41, 0x82, 0x1a, 0x1b, 0x41, 0x20, 0x2e, 0x78, +0xca, 0x88, 0x03, 0x5c, 0x0a, 0x23, 0xcd, 0xb9, 0xc3, 0x48, 0x67, 0x42, +0x4a, 0xe1, 0xe7, 0x56, 0x0f, 0x02, 0x81, 0xc0, 0x46, 0x10, 0x88, 0xa3, +0x6d, 0xec, 0xf1, 0x1c, 0xa0, 0xb9, 0xfc, 0xc2, 0x95, 0x90, 0xd2, 0x96, +0x40, 0x70, 0x82, 0x1a, 0x1b, 0x41, 0x20, 0x8e, 0x74, 0x0b, 0x78, 0x71, +0x00, 0x0e, 0x60, 0x3b, 0xbf, 0xe0, 0xf2, 0xb5, 0xc3, 0x88, 0xed, 0x35, +0xac, 0x0a, 0x04, 0x25, 0xae, 0x58, 0xef, 0xa6, 0x07, 0x42, 0x5f, 0x8d, +0x75, 0x3f, 0xaf, 0x38, 0x00, 0x07, 0xe7, 0x84, 0xa1, 0x86, 0xc1, 0xee, +0x77, 0x37, 0x57, 0x8f, 0xf0, 0x23, 0x10, 0xd8, 0x30, 0x26, 0xf9, 0x87, +0x57, 0x49, 0xea, 0x08, 0x9b, 0x2e, 0x18, 0x90, 0xa9, 0x16, 0x61, 0x88, +0x7c, 0xbc, 0xff, 0xa6, 0x9d, 0x5c, 0x11, 0x08, 0xac, 0x67, 0xd3, 0x62, +0x8c, 0xad, 0x71, 0x6e, 0x5a, 0x6b, 0x03, 0xec, 0xf6, 0x16, 0xe6, 0x0a, +0xf2, 0x0b, 0xb1, 0xbd, 0x86, 0x0f, 0x20, 0x10, 0xd8, 0x28, 0xe1, 0x25, +0x11, 0x08, 0x72, 0x0d, 0x70, 0xd9, 0x5b, 0x28, 0x78, 0x7e, 0x21, 0x7b, +0x4c, 0x54, 0xbe, 0xb6, 0x08, 0x04, 0x49, 0x6a, 0xac, 0xf7, 0xf0, 0x52, +0x58, 0xe2, 0x8a, 0x30, 0xc0, 0xee, 0x50, 0x8b, 0xcb, 0xdf, 0x1f, 0x29, +0xa6, 0x30, 0x68, 0x08, 0x6c, 0xf1, 0xff, 0x3d, 0xf9, 0x81, 0x7f, 0xdb, +0x23, 0x10, 0x12, 0x97, 0xa5, 0xcc, 0x15, 0xeb, 0x39, 0xbc, 0x64, 0xab, +0x97, 0xe8, 0xc2, 0x0a, 0x47, 0xc2, 0x48, 0x4b, 0x6d, 0xe1, 0x95, 0x83, +0x03, 0x78, 0xd6, 0x5e, 0xf7, 0xda, 0xce, 0x58, 0xcd, 0xdc, 0x4e, 0x35, +0x3d, 0x11, 0x8b, 0x45, 0xff, 0x2d, 0x8b, 0x09, 0xd6, 0x6b, 0x78, 0x49, +0x7b, 0x8d, 0x05, 0x77, 0xa1, 0x00, 0xac, 0xe7, 0x16, 0x6a, 0x0b, 0x23, +0x9d, 0x4c, 0x94, 0x7d, 0xb8, 0x0d, 0x2e, 0x34, 0x6d, 0xa1, 0x61, 0x6e, +0xd3, 0x5a, 0x3b, 0x2f, 0x31, 0x5f, 0x69, 0x41, 0x80, 0x61, 0xb5, 0x9b, +0x69, 0x25, 0x43, 0x12, 0x1a, 0xb6, 0x45, 0xa1, 0xb6, 0x10, 0xd2, 0xd5, +0x78, 0xa8, 0xe6, 0x0f, 0x54, 0x0c, 0xac, 0xad, 0x89, 0x85, 0x11, 0x0a, +0x7b, 0xdf, 0xed, 0x5d, 0x7e, 0x0f, 0x81, 0xc0, 0x7a, 0xf5, 0x1e, 0x4c, +0x11, 0x06, 0x40, 0x3b, 0xa2, 0x70, 0xd1, 0xe5, 0x9d, 0xf5, 0x64, 0xa8, +0x2c, 0xee, 0xa1, 0x37, 0x24, 0xff, 0xaf, 0x9e, 0x81, 0x8a, 0x88, 0x5e, +0x2b, 0x1a, 0x84, 0x9f, 0xde, 0x05, 0xa2, 0x87, 0x44, 0x75, 0xec, 0x5b, +0xc3, 0xb0, 0xb6, 0x73, 0x0f, 0x32, 0xde, 0x09, 0x2b, 0xc1, 0x87, 0x84, +0x6d, 0xed, 0xa2, 0x10, 0xe4, 0x19, 0x4e, 0x95, 0xad, 0xaa, 0xf7, 0xb0, +0xb7, 0xf9, 0x98, 0x8a, 0x85, 0x15, 0x0a, 0x5d, 0x4c, 0x6d, 0x0e, 0xa3, +0xf5, 0x45, 0x61, 0x4d, 0x2c, 0xb1, 0x71, 0x05, 0xc2, 0x6f, 0x16, 0xb8, +0x13, 0x7a, 0x70, 0x1e, 0x55, 0x48, 0xb9, 0xee, 0x76, 0x2e, 0x29, 0x0c, +0x61, 0xee, 0xe1, 0xe8, 0x62, 0xa8, 0x0d, 0xcb, 0x6c, 0xf8, 0xa9, 0xa7, +0x04, 0x35, 0x67, 0x3a, 0x30, 0xc7, 0xa9, 0x68, 0xf0, 0x2f, 0xfe, 0xd1, +0x28, 0xaf, 0x85, 0x05, 0xc1, 0x94, 0xac, 0xc6, 0xd8, 0xcd, 0x4c, 0x57, +0x5a, 0x17, 0x6b, 0x48, 0xc9, 0x7a, 0x13, 0x3d, 0xc5, 0x9b, 0x59, 0x1c, +0x31, 0xc4, 0x61, 0x4c, 0x2f, 0x61, 0x76, 0x75, 0x74, 0x4f, 0x2d, 0x7d, +0xc8, 0x6d, 0x92, 0xc5, 0xf0, 0x6a, 0x62, 0x59, 0xcb, 0xff, 0x7a, 0xb9, +0x8f, 0x7a, 0x4f, 0xaf, 0x1d, 0xac, 0xff, 0xb0, 0x92, 0x9f, 0x73, 0x84, +0x95, 0x46, 0x12, 0x84, 0xd6, 0x16, 0xb0, 0xc4, 0x1d, 0x21, 0xa3, 0x08, +0x84, 0x0d, 0x39, 0xf5, 0x10, 0x66, 0xa2, 0x6d, 0x39, 0xed, 0xbc, 0xfd, +0xfb, 0x27, 0x21, 0xdd, 0x39, 0x73, 0xab, 0x3b, 0xda, 0xc8, 0xa1, 0xa4, +0xe4, 0x02, 0xa1, 0x13, 0xab, 0x75, 0x81, 0x20, 0xbc, 0x84, 0x38, 0xf8, +0x31, 0xcc, 0x59, 0x87, 0xde, 0x69, 0x29, 0x84, 0x94, 0x59, 0x18, 0x92, +0x08, 0x44, 0x2f, 0xc9, 0x69, 0x4e, 0x83, 0x8f, 0x69, 0x32, 0x0f, 0xc4, +0x7c, 0x91, 0x0a, 0x0c, 0x10, 0x5a, 0x6a, 0x4d, 0x18, 0x16, 0x97, 0x37, +0xe6, 0x39, 0x71, 0xfa, 0xf9, 0xe3, 0xee, 0x11, 0xef, 0x61, 0xec, 0x83, +0x70, 0x29, 0x3a, 0x1d, 0x03, 0x02, 0xd1, 0x9a, 0x30, 0x20, 0x10, 0x24, +0xa7, 0xab, 0x4c, 0x0c, 0x97, 0x08, 0x09, 0x23, 0x0e, 0x83, 0x0a, 0x44, +0xad, 0xf9, 0x07, 0x73, 0xfa, 0x78, 0xae, 0xe1, 0x19, 0xb1, 0x6b, 0x3e, +0x7e, 0xcf, 0x30, 0x96, 0x34, 0x39, 0x9c, 0xdd, 0x6b, 0xa4, 0x62, 0x69, +0x40, 0x6a, 0x3a, 0xf0, 0x26, 0x03, 0xd0, 0x88, 0xc2, 0xad, 0x26, 0x11, +0xa5, 0x6a, 0xe7, 0xdf, 0xca, 0x25, 0x84, 0x72, 0xbc, 0xf6, 0x26, 0xe6, +0x0e, 0x13, 0xce, 0x3a, 0x0c, 0xc8, 0xbd, 0xa4, 0x17, 0x51, 0x91, 0xa7, +0xb0, 0x09, 0x17, 0xfd, 0xfc, 0x3d, 0xc7, 0x81, 0xf7, 0x30, 0x56, 0x7b, +0x13, 0x73, 0x7f, 0x09, 0x77, 0x3a, 0x0c, 0xcc, 0x94, 0x53, 0x10, 0x8c, +0xa7, 0x30, 0xb5, 0xe0, 0xb2, 0xea, 0x45, 0x3f, 0xa3, 0x2e, 0x8e, 0x7a, +0x09, 0x0c, 0xb9, 0x87, 0x3a, 0x84, 0x3a, 0xe7, 0xf7, 0xa2, 0x75, 0x37, +0x28, 0xc9, 0xce, 0x43, 0x98, 0x13, 0x97, 0x73, 0xa3, 0x6e, 0xea, 0xd0, +0x17, 0xfd, 0x68, 0xab, 0x10, 0xbc, 0x87, 0xf2, 0x42, 0x9d, 0x6b, 0x0c, +0x6a, 0x61, 0x06, 0xe5, 0xac, 0xf0, 0xc1, 0x93, 0x88, 0x75, 0x2e, 0x22, +0x08, 0x1d, 0xb5, 0x9e, 0xd8, 0x9a, 0x4a, 0x24, 0x07, 0xf1, 0x1e, 0x30, +0x57, 0xe0, 0x90, 0xa5, 0x8a, 0x03, 0x49, 0x69, 0x58, 0xe3, 0xf0, 0x9d, +0xd1, 0xc6, 0x43, 0xd0, 0x7b, 0x9a, 0xef, 0x9d, 0x0d, 0xac, 0x5b, 0xa9, +0xf2, 0xc2, 0xd2, 0x26, 0xb9, 0x97, 0x33, 0x9d, 0x6c, 0xb1, 0x34, 0x21, +0x9f, 0x1c, 0x02, 0x21, 0xdf, 0x83, 0x06, 0x7c, 0xb0, 0x87, 0xbb, 0x5f, +0xf0, 0x67, 0xbf, 0xf8, 0x5b, 0x9b, 0x3b, 0x15, 0x83, 0xcd, 0x3c, 0xc4, +0x68, 0x8b, 0x24, 0x65, 0xad, 0xf5, 0x85, 0xfa, 0x52, 0xbf, 0x0b, 0xf9, +0xfa, 0x88, 0x03, 0xc0, 0x41, 0x24, 0x5c, 0x36, 0xd2, 0x42, 0xa9, 0xa5, +0xbd, 0xa3, 0x85, 0x96, 0xf4, 0xe2, 0x1b, 0x35, 0x4d, 0xd4, 0x3e, 0x33, +0xfb, 0xf7, 0xd7, 0x4c, 0xbd, 0xcf, 0xf0, 0xff, 0xad, 0xed, 0x59, 0xb8, +0x53, 0x57, 0xd2, 0x21, 0x0e, 0x00, 0xe7, 0x99, 0x47, 0x13, 0x87, 0x9e, +0xcf, 0x3c, 0xd8, 0xc5, 0x5f, 0xc3, 0x68, 0x6b, 0xf7, 0x8b, 0xc7, 0x32, +0x7d, 0x9e, 0x7a, 0x12, 0x5d, 0xc3, 0x45, 0x56, 0x80, 0xf4, 0x8c, 0xc3, +0x9a, 0x08, 0x68, 0xff, 0xab, 0x54, 0x5e, 0xac, 0x39, 0x5f, 0x81, 0x38, +0x00, 0x9c, 0x09, 0xb7, 0x8d, 0x90, 0x87, 0xd0, 0x96, 0xe4, 0x3d, 0xe5, +0x1d, 0x42, 0x31, 0xb0, 0xf7, 0x86, 0x5f, 0x5d, 0xec, 0x75, 0xc1, 0xb7, +0x66, 0x17, 0x7f, 0x5d, 0x78, 0x65, 0x67, 0xae, 0xb6, 0x12, 0xae, 0x7d, +0x98, 0x7a, 0xa9, 0xe1, 0x73, 0x57, 0xef, 0x21, 0xd5, 0xf8, 0xd3, 0xcf, +0xed, 0x28, 0x67, 0x05, 0x38, 0x0f, 0xe2, 0x50, 0x7f, 0x58, 0x28, 0x14, +0x82, 0xa3, 0x5e, 0x81, 0x2e, 0xfe, 0x6b, 0x8b, 0xbd, 0x2e, 0xde, 0x2f, +0x16, 0xfb, 0xd9, 0xd8, 0xe4, 0xfe, 0x9e, 0xf5, 0xd9, 0x93, 0xa7, 0x5b, +0x2d, 0x35, 0xd7, 0x3b, 0x44, 0xcc, 0xbd, 0xcf, 0xd1, 0x0f, 0x40, 0xfa, +0xe4, 0x37, 0xde, 0x03, 0xc0, 0x59, 0x62, 0x94, 0x00, 0x97, 0x68, 0x95, +0x70, 0x54, 0x1c, 0x6a, 0xfb, 0x7c, 0x36, 0x86, 0x6f, 0x43, 0x32, 0x47, +0x05, 0x20, 0x0c, 0xf3, 0x58, 0x01, 0xb0, 0xbb, 0x7c, 0x5f, 0x9e, 0x1d, +0x16, 0x63, 0x1c, 0x59, 0xe8, 0xa3, 0x85, 0x31, 0xf5, 0xe7, 0x74, 0x89, +0xca, 0x5c, 0xd5, 0x9b, 0xe2, 0xf2, 0x1f, 0x80, 0xeb, 0x2c, 0x2e, 0x52, +0x65, 0x50, 0x4d, 0x77, 0x2a, 0xc8, 0xe7, 0x28, 0x29, 0x0e, 0x5b, 0x8b, +0x7f, 0x28, 0x00, 0xfa, 0x19, 0xd5, 0x9e, 0x85, 0x75, 0x0e, 0xec, 0xfa, +0x75, 0xb7, 0x5f, 0x43, 0x35, 0xde, 0xe2, 0x56, 0x72, 0x41, 0xfa, 0x4e, +0x52, 0x08, 0x44, 0x70, 0x08, 0x12, 0x81, 0x00, 0xb8, 0xc0, 0x14, 0x63, +0x52, 0xea, 0xa2, 0xa7, 0x8b, 0x60, 0xca, 0xe4, 0xa3, 0xdb, 0x51, 0x19, +0xa3, 0x8b, 0x6f, 0x2a, 0x71, 0x08, 0x3d, 0x80, 0x35, 0x2f, 0xc0, 0xda, +0xda, 0x2e, 0x3f, 0x5c, 0xe8, 0x65, 0x97, 0xaf, 0xe6, 0xd6, 0xcb, 0xaf, +0x73, 0xed, 0xfa, 0x93, 0x09, 0x44, 0xd8, 0x66, 0x3e, 0x45, 0xdb, 0xf9, +0xa0, 0xc7, 0x16, 0x02, 0x01, 0x70, 0x81, 0x28, 0xed, 0xd1, 0xed, 0x9d, +0x0a, 0xda, 0x67, 0x5f, 0x77, 0xc4, 0xa9, 0xc5, 0x42, 0x17, 0x19, 0xbb, +0x33, 0xb7, 0xe5, 0x93, 0x47, 0xbf, 0xf7, 0x9e, 0xc5, 0x3f, 0xdc, 0xfd, +0xdb, 0x4a, 0x9e, 0x1d, 0x0b, 0xff, 0x30, 0xe7, 0x6d, 0xe4, 0x67, 0x7e, +0x76, 0xde, 0x26, 0xc5, 0x65, 0x4d, 0x08, 0x04, 0x40, 0x65, 0x02, 0xb1, +0x76, 0xa7, 0x73, 0xb8, 0x70, 0xab, 0x67, 0x71, 0x65, 0x57, 0x1f, 0x2e, +0xdc, 0x61, 0xf5, 0x8e, 0xdd, 0xa5, 0x87, 0xb1, 0xfa, 0x3d, 0xb6, 0x15, +0xe7, 0x0f, 0x45, 0xe0, 0x49, 0x8c, 0x7f, 0x76, 0x8d, 0x34, 0x6c, 0xcc, +0x31, 0xb6, 0xf4, 0x0c, 0xc2, 0x56, 0xae, 0x4b, 0xde, 0x27, 0x1e, 0x04, +0x40, 0xc5, 0xc4, 0x4a, 0x54, 0x3f, 0xdb, 0x09, 0x6a, 0x4e, 0x20, 0x5c, +0xcc, 0x6d, 0x9d, 0xfc, 0x2b, 0xd3, 0x89, 0xbf, 0x55, 0xa1, 0xa3, 0x3b, +0x77, 0x15, 0xa5, 0x33, 0x16, 0x7a, 0x02, 0x36, 0xce, 0x6f, 0x62, 0xfd, +0x88, 0xc0, 0x4e, 0x81, 0xd0, 0x05, 0xfa, 0xd9, 0x1d, 0x2d, 0xb1, 0x73, +0x10, 0xda, 0x6b, 0xcb, 0x7f, 0x5d, 0xde, 0x11, 0xc0, 0x45, 0xa2, 0x24, +0xaa, 0x65, 0x81, 0xdd, 0x33, 0x79, 0x6d, 0x08, 0xea, 0x6c, 0xcd, 0xfe, +0xab, 0xb0, 0x55, 0x98, 0xc4, 0xdd, 0x6b, 0x6e, 0xc0, 0x96, 0x2b, 0x99, +0x98, 0x5e, 0x09, 0x44, 0xcc, 0x30, 0xa4, 0x39, 0x31, 0x0f, 0x00, 0x17, +0xb9, 0x7c, 0xa2, 0x5a, 0x77, 0x6d, 0x47, 0xc3, 0x47, 0x1a, 0x32, 0xd2, +0x5d, 0xff, 0xda, 0x21, 0xad, 0x30, 0xb1, 0xfb, 0xea, 0xeb, 0xb9, 0x72, +0x77, 0x7d, 0xc3, 0x36, 0x77, 0xf7, 0x24, 0x7f, 0x15, 0xbb, 0xed, 0xb7, +0x11, 0x08, 0xce, 0x41, 0x00, 0xa4, 0xda, 0xdd, 0xb9, 0x83, 0xa5, 0xae, +0xa5, 0xca, 0x5c, 0xcd, 0xdd, 0x1c, 0x08, 0x43, 0xa5, 0xe1, 0xa6, 0x2d, +0x0f, 0x41, 0x6f, 0x94, 0x33, 0x37, 0xbd, 0xc5, 0x14, 0x88, 0x89, 0x47, +0x0f, 0x90, 0x68, 0xf2, 0x1e, 0x15, 0x88, 0x9c, 0x8d, 0xf0, 0xcc, 0xfd, +0x1c, 0xec, 0x12, 0x1b, 0xe0, 0xd5, 0x5d, 0xf1, 0x5a, 0x0a, 0xec, 0x22, +0x1d, 0x96, 0xf3, 0x5f, 0x0b, 0x81, 0x00, 0xb8, 0xca, 0xd5, 0x44, 0x75, +0x81, 0x4b, 0x78, 0x16, 0x84, 0xa1, 0x39, 0x16, 0xf7, 0xa2, 0xb7, 0x54, +0xac, 0x56, 0xec, 0xe6, 0xb4, 0x36, 0x63, 0x04, 0x60, 0x04, 0x81, 0x30, +0xf9, 0x05, 0x26, 0x7d, 0x9b, 0x4c, 0xee, 0xc0, 0x79, 0x9a, 0x48, 0x02, +0x81, 0x07, 0x01, 0x50, 0x5a, 0x20, 0xdc, 0xc7, 0xb8, 0x6f, 0x2a, 0x61, +0x20, 0xbf, 0xd0, 0x36, 0x77, 0xb7, 0xb3, 0x45, 0x8a, 0x8b, 0x57, 0x76, +0x4d, 0x37, 0x57, 0x80, 0x5a, 0x04, 0x22, 0x76, 0x92, 0x9a, 0x1c, 0xc3, +0x78, 0xe3, 0x2c, 0x86, 0x17, 0xa1, 0x42, 0xe3, 0xc7, 0x0f, 0x00, 0xf4, +0x24, 0x10, 0xde, 0x6b, 0x98, 0x79, 0x33, 0x7d, 0xf1, 0x2a, 0x51, 0xed, +0x76, 0x1c, 0xba, 0x74, 0x07, 0xce, 0xe5, 0x20, 0x10, 0x00, 0xd7, 0x89, +0xd2, 0x6e, 0x23, 0xa2, 0x40, 0x10, 0x4e, 0xea, 0x97, 0x79, 0xef, 0x58, +0xba, 0x9a, 0xac, 0x16, 0x91, 0x41, 0x20, 0x00, 0x22, 0x08, 0x84, 0x8b, +0x54, 0x5a, 0x18, 0xa1, 0x02, 0x05, 0xaf, 0x01, 0x6f, 0xd5, 0xde, 0x08, +0x77, 0x69, 0x3c, 0xfa, 0x0d, 0x0b, 0x00, 0x5c, 0xe0, 0xee, 0x22, 0x35, +0x49, 0xbb, 0x18, 0x52, 0x9a, 0x78, 0x15, 0x78, 0x11, 0x2e, 0x52, 0x1b, +0x70, 0x23, 0x32, 0x78, 0xa3, 0x00, 0xa9, 0xdd, 0xfe, 0x57, 0x13, 0xfa, +0xac, 0x40, 0xf8, 0x1d, 0x25, 0xe2, 0x30, 0x90, 0xc7, 0xba, 0x27, 0xa4, +0x79, 0xb5, 0xf3, 0xaf, 0xc9, 0x65, 0xe0, 0x95, 0x02, 0x5c, 0xe0, 0x72, +0xb3, 0xbe, 0xb3, 0x6d, 0x12, 0x7c, 0x8c, 0x98, 0x1d, 0xde, 0x60, 0xec, +0x49, 0x56, 0x5f, 0xf5, 0x22, 0xf4, 0xae, 0x09, 0xf2, 0x10, 0x00, 0x17, +0x88, 0x51, 0xc1, 0x74, 0xe6, 0xba, 0x51, 0xff, 0x7d, 0x61, 0x4c, 0xa6, +0xbd, 0x8b, 0xbc, 0x8b, 0x93, 0x17, 0x03, 0x80, 0x54, 0xee, 0xbe, 0x8b, +0x9c, 0xa0, 0xf6, 0xe2, 0x80, 0xe7, 0xc0, 0xb8, 0xdb, 0x75, 0xbb, 0x9f, +0x23, 0x0f, 0x01, 0x50, 0xef, 0x4e, 0x6e, 0xcf, 0x44, 0x74, 0x84, 0x95, +0x20, 0x81, 0xe7, 0x7a, 0xa5, 0xf8, 0xc1, 0x5c, 0x69, 0x3a, 0xf1, 0xc4, +0x01, 0x8e, 0x13, 0xe5, 0xb2, 0xa0, 0xbd, 0x93, 0x98, 0x78, 0x30, 0x1c, +0x1d, 0x7b, 0x7a, 0x53, 0xa0, 0x3b, 0x59, 0x1d, 0x47, 0xcb, 0x0d, 0x80, +0xc4, 0xbb, 0xb8, 0x57, 0x3b, 0xbc, 0x3d, 0x02, 0xe1, 0x27, 0x39, 0x9e, +0x03, 0x28, 0xbb, 0xaa, 0xe7, 0xae, 0x5e, 0x26, 0x24, 0xff, 0x96, 0x8d, +0x09, 0xc0, 0x71, 0xa2, 0xe4, 0x1f, 0xf4, 0x3e, 0xe8, 0x1d, 0xe2, 0x40, +0x4f, 0x25, 0xb0, 0xec, 0x3e, 0x7f, 0x73, 0xc5, 0x8b, 0x30, 0x1b, 0x18, +0x00, 0x38, 0xc0, 0xe4, 0x32, 0x1c, 0x90, 0xe3, 0x10, 0x1c, 0x5c, 0xdd, +0xa0, 0x5c, 0xf1, 0x22, 0xf4, 0xb6, 0x3a, 0xc7, 0x79, 0x08, 0x80, 0xfd, +0xec, 0xa9, 0x45, 0xdf, 0x33, 0xf9, 0x9e, 0x79, 0x0f, 0x88, 0x03, 0xc4, +0xf0, 0x20, 0xdc, 0xc5, 0x92, 0x57, 0xc2, 0x4c, 0x00, 0x89, 0x76, 0x6f, +0xaf, 0x26, 0xed, 0x8b, 0x89, 0x4b, 0x72, 0x10, 0xb6, 0x38, 0x54, 0x20, +0xf1, 0x6a, 0x33, 0xb2, 0xf3, 0xdf, 0x92, 0x03, 0x03, 0x88, 0x3d, 0x39, +0xdd, 0x89, 0xf0, 0x12, 0x3b, 0x36, 0x78, 0xe6, 0x3d, 0x9c, 0xd9, 0xa0, +0x44, 0x68, 0x06, 0x89, 0x37, 0x0b, 0xf0, 0x8a, 0x18, 0xd5, 0x4b, 0xcf, +0xe2, 0xc2, 0x24, 0xa5, 0xc1, 0x7a, 0xab, 0x7e, 0x61, 0x96, 0x1c, 0xc0, +0x72, 0x25, 0xb4, 0x79, 0xc5, 0x8b, 0x70, 0x9c, 0xde, 0x07, 0xd8, 0xb7, +0x7b, 0x8b, 0xe1, 0x3d, 0xbc, 0x08, 0x2f, 0x11, 0x5a, 0x1a, 0x1b, 0x11, +0x84, 0x45, 0x16, 0xe4, 0x18, 0xa1, 0xcc, 0xc8, 0x5e, 0x04, 0x1b, 0x17, +0x80, 0x94, 0xde, 0x83, 0xf3, 0xe1, 0xa5, 0xb5, 0xc9, 0xcf, 0x49, 0xe9, +0xa1, 0x59, 0x62, 0x8d, 0x2f, 0xf7, 0xbc, 0xf0, 0xe1, 0xea, 0x35, 0xb6, +0x00, 0x90, 0xca, 0x7b, 0x78, 0xb1, 0x93, 0x9b, 0x78, 0xcc, 0xe3, 0x8d, +0xab, 0xd4, 0xc2, 0x10, 0xd9, 0xf0, 0x22, 0x00, 0x52, 0x86, 0x97, 0xd6, +0x76, 0x72, 0x9c, 0x96, 0x1e, 0x33, 0x9c, 0x14, 0x3b, 0x8c, 0x94, 0xda, +0xc8, 0x45, 0x00, 0x44, 0x14, 0x88, 0xb0, 0xab, 0xe6, 0x8b, 0xf0, 0x12, +0x0c, 0x34, 0x9e, 0x5a, 0x13, 0x07, 0x47, 0x9e, 0x0c, 0x60, 0x7b, 0xb7, +0x77, 0xc6, 0x3b, 0xb0, 0x09, 0xe9, 0x67, 0xcd, 0xf9, 0x10, 0x88, 0xb1, +0x68, 0x2c, 0xac, 0x44, 0x38, 0x14, 0xe0, 0xaa, 0x07, 0xb1, 0x96, 0x5b, +0x90, 0x56, 0x05, 0x2a, 0x1a, 0xcf, 0x7a, 0x2f, 0x21, 0x10, 0x6c, 0x36, +0x1a, 0x0c, 0x35, 0x11, 0x12, 0x05, 0xf0, 0xbc, 0x3c, 0x41, 0x1d, 0x7a, +0x07, 0xf2, 0xff, 0xbf, 0x7e, 0xfd, 0xda, 0xd5, 0xda, 0x9b, 0xd8, 0xee, +0x38, 0xc4, 0x68, 0xd5, 0x42, 0xa8, 0x09, 0xa0, 0xa1, 0x89, 0xbd, 0xe6, +0x1d, 0x88, 0x38, 0xec, 0x6d, 0x94, 0x46, 0x92, 0x9a, 0xf0, 0x52, 0xe6, +0x85, 0x7d, 0x71, 0x84, 0x9a, 0x00, 0xe2, 0x86, 0x99, 0xc2, 0xa4, 0xb3, +0x76, 0xbc, 0x0c, 0x6f, 0x86, 0x93, 0xff, 0xf7, 0x17, 0xae, 0x1c, 0xa9, +0x51, 0xa7, 0x84, 0x10, 0x81, 0x48, 0x76, 0x06, 0xc2, 0x6f, 0x70, 0xa6, +0x04, 0x9f, 0x03, 0x91, 0x00, 0xf0, 0x2c, 0x7a, 0x1d, 0xa3, 0x78, 0x08, +0x62, 0xa1, 0x10, 0x88, 0xd7, 0x70, 0xe4, 0x2a, 0x51, 0x63, 0xb4, 0x55, +0x1e, 0x64, 0x0c, 0xe5, 0x12, 0x05, 0x2f, 0x02, 0xf3, 0x86, 0x77, 0x3a, +0x39, 0x92, 0xd6, 0x00, 0x51, 0xb9, 0x69, 0x5f, 0x1b, 0x11, 0x82, 0x30, +0xac, 0x74, 0xb1, 0xe7, 0x0d, 0x02, 0x81, 0x40, 0xc4, 0xf0, 0x12, 0x66, +0xbf, 0x60, 0xbf, 0xf4, 0x48, 0x63, 0xe5, 0x43, 0x68, 0x4f, 0x0f, 0x60, +0x42, 0x4d, 0x32, 0xc9, 0x35, 0xdc, 0xa4, 0xe6, 0x77, 0x6b, 0x32, 0xf9, +0xa7, 0x33, 0x13, 0x8f, 0x56, 0x1b, 0xc3, 0x10, 0x65, 0xe7, 0x2e, 0xe3, +0xcd, 0x84, 0x8d, 0xee, 0x27, 0xc7, 0x4e, 0xb4, 0xf3, 0x18, 0x84, 0x49, +0x01, 0x02, 0x6f, 0x22, 0xb0, 0xcb, 0xbb, 0x44, 0x3f, 0xc9, 0xf0, 0x24, +0x3a, 0xe7, 0xcc, 0xa2, 0x1c, 0xe4, 0x11, 0x62, 0x2e, 0xc4, 0xd1, 0x3c, +0x1a, 0xbf, 0x49, 0x42, 0x24, 0x00, 0x5e, 0x30, 0xbb, 0xeb, 0x8d, 0xd1, +0x70, 0xd9, 0x07, 0x1f, 0x1f, 0x41, 0xd8, 0x28, 0x95, 0x77, 0x79, 0x8b, +0x79, 0xaa, 0xdb, 0x8b, 0x04, 0x63, 0x17, 0xe0, 0x99, 0xeb, 0x1e, 0x63, +0xb2, 0x11, 0x76, 0xea, 0x9a, 0x69, 0xab, 0x92, 0xe8, 0x45, 0x72, 0xb9, +0xba, 0x0d, 0x8d, 0x23, 0xa7, 0x06, 0x70, 0x8c, 0x58, 0x65, 0x84, 0x84, +0x9d, 0xfa, 0x17, 0x0a, 0xff, 0x7e, 0x17, 0xf7, 0x37, 0xc1, 0x9c, 0x9d, +0xab, 0x09, 0xeb, 0x8d, 0xe2, 0x0c, 0x0e, 0xd3, 0x01, 0xe4, 0xd8, 0x95, +0xe1, 0x4d, 0x40, 0x6a, 0xaf, 0xf7, 0x4a, 0xa8, 0x49, 0x04, 0x62, 0xad, +0xbc, 0x9b, 0x71, 0x0b, 0xb0, 0x31, 0xe1, 0x5c, 0x9a, 0x1e, 0x38, 0x24, +0x01, 0x21, 0x15, 0x97, 0x12, 0xd6, 0x6b, 0x67, 0x80, 0x44, 0x38, 0x10, +0x09, 0x80, 0xcf, 0xdc, 0x52, 0xb4, 0x74, 0xa6, 0x9c, 0x10, 0x52, 0x72, +0x35, 0x34, 0x2a, 0x07, 0x47, 0x6d, 0xb8, 0x49, 0xbb, 0x0d, 0x20, 0x12, +0x00, 0x91, 0x77, 0x64, 0x8e, 0xe6, 0x7e, 0x90, 0x9f, 0x4b, 0xa1, 0xd1, +0xb5, 0xd6, 0x33, 0xe2, 0x59, 0xf8, 0xbe, 0x64, 0x6c, 0x6c, 0x00, 0x0c, +0xd1, 0xc3, 0x4c, 0x8e, 0xf6, 0x06, 0x90, 0xd8, 0xf3, 0xbd, 0xe2, 0x45, +0x88, 0x10, 0x84, 0xed, 0x67, 0x4c, 0x7e, 0x82, 0x62, 0x0b, 0x00, 0x3b, +0xd9, 0x52, 0xdd, 0x1c, 0xc6, 0x1d, 0x12, 0x90, 0x90, 0xe9, 0x8a, 0x07, +0xb1, 0x26, 0x10, 0xfe, 0xf7, 0xa8, 0x6a, 0x02, 0xb0, 0xa4, 0xea, 0xff, +0x4f, 0x8b, 0x70, 0xa8, 0x71, 0xdc, 0xae, 0x09, 0x84, 0xde, 0x8d, 0xc2, +0xa6, 0x06, 0xe0, 0x33, 0xc9, 0x9a, 0xb3, 0x21, 0x10, 0x50, 0x9b, 0xf7, +0x2b, 0xe2, 0x10, 0x0a, 0x84, 0x11, 0x0d, 0x42, 0x4c, 0x00, 0x08, 0x04, +0x74, 0xc2, 0xa1, 0x84, 0xb5, 0x84, 0x92, 0x7e, 0xff, 0xfe, 0xfd, 0xe9, +0xa2, 0x2c, 0x53, 0xd9, 0xc4, 0x78, 0x05, 0x08, 0x77, 0x62, 0x29, 0x2e, +0x89, 0x41, 0x20, 0x20, 0x07, 0x7b, 0x43, 0x4d, 0x32, 0x1e, 0xf5, 0x9e, +0x94, 0xf0, 0xf7, 0x29, 0xcd, 0x06, 0xc8, 0x2f, 0x12, 0xb8, 0xeb, 0x90, +0xcd, 0x0b, 0x16, 0x0f, 0x40, 0xcf, 0x37, 0xe8, 0x7f, 0xab, 0xe9, 0x01, +0xb9, 0xf0, 0xea, 0x5d, 0xd3, 0x6c, 0x10, 0x71, 0x00, 0x78, 0xc1, 0x5d, +0x26, 0x8b, 0x08, 0x45, 0x68, 0x7e, 0x12, 0x2d, 0xaf, 0xcc, 0xde, 0x39, +0xc1, 0xe3, 0x84, 0xdc, 0xe3, 0x57, 0x36, 0x25, 0x3a, 0x86, 0x45, 0x08, +0xf4, 0x82, 0x2c, 0x3b, 0x86, 0xe5, 0x57, 0xef, 0x31, 0x2c, 0x08, 0x03, +0x00, 0xc0, 0xa0, 0x5e, 0xb1, 0x5b, 0xbf, 0x0b, 0xc5, 0x39, 0x42, 0x9f, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0xb9, +0xff, 0xb1, 0x85, 0xc7, 0x00, 0x00, 0x00, 0x1f, 0xf8, 0xfa, 0xf5, 0xeb, +0x7f, 0x10, 0x08, 0x00, 0x00, 0x58, 0xf3, 0x1e, 0xde, 0x10, 0x08, 0x00, +0x00, 0x58, 0xf3, 0x1e, 0x10, 0x08, 0x00, 0x00, 0xf8, 0xc0, 0xec, 0xc5, +0x01, 0x81, 0x00, 0x00, 0x80, 0x77, 0x16, 0x23, 0x0e, 0x08, 0x04, 0x00, +0x00, 0xb8, 0xdb, 0x8a, 0x38, 0xbc, 0x79, 0x6f, 0x02, 0x00, 0x00, 0x46, +0x15, 0x87, 0x2f, 0x5f, 0xbe, 0xfc, 0x77, 0x45, 0x1c, 0xc4, 0x26, 0x1e, +0x0f, 0x00, 0xc0, 0x98, 0x4c, 0x4f, 0xc4, 0x41, 0xec, 0xce, 0x23, 0x02, +0x00, 0x18, 0x8f, 0xf9, 0x89, 0x30, 0x20, 0x10, 0x00, 0x00, 0x78, 0x0d, +0xeb, 0xf6, 0xed, 0xdb, 0xb7, 0xff, 0xb9, 0x7f, 0x73, 0x13, 0x00, 0x00, +0xd0, 0x39, 0x37, 0x73, 0xbe, 0xe1, 0xa5, 0xf9, 0xbf, 0x0b, 0x00, 0x00, +0xbd, 0x0b, 0x83, 0xf7, 0x08, 0xde, 0x0e, 0x18, 0x25, 0xae, 0x00, 0x00, +0xbd, 0x0a, 0xc3, 0x1f, 0x9b, 0xf7, 0x84, 0x93, 0x36, 0x8c, 0x12, 0x57, +0x00, 0x80, 0x8e, 0x78, 0x74, 0x60, 0x15, 0x51, 0x38, 0xe1, 0x31, 0x50, +0xe2, 0x0a, 0x00, 0xd0, 0xa3, 0x30, 0x9c, 0x0c, 0x23, 0x91, 0xa0, 0x06, +0x00, 0xe8, 0x94, 0x0f, 0x89, 0xe7, 0xef, 0xdf, 0xbf, 0xff, 0xb3, 0x2c, +0xcb, 0xe3, 0xd7, 0x2b, 0x02, 0x11, 0x39, 0x41, 0xad, 0xa7, 0xb4, 0x01, +0x00, 0x20, 0x13, 0xb3, 0x7a, 0x0c, 0xf2, 0xeb, 0xcf, 0x9f, 0x3f, 0xdf, +0x7e, 0xfd, 0xfa, 0xf5, 0xf6, 0xe3, 0xc7, 0x8f, 0x4b, 0xe2, 0xe0, 0xae, +0xe5, 0x1f, 0x24, 0xc4, 0x35, 0x79, 0x93, 0xaf, 0xf1, 0x08, 0x77, 0x51, +0x11, 0x05, 0x00, 0x90, 0x87, 0xbb, 0x4d, 0x3c, 0x8b, 0xc7, 0x20, 0xc2, +0x10, 0xc3, 0x73, 0x70, 0x7f, 0xc3, 0x4b, 0x7b, 0x0f, 0xc8, 0xdd, 0x55, +0x08, 0x9e, 0x84, 0xb8, 0xf0, 0x1e, 0x00, 0x00, 0x32, 0x30, 0xe9, 0x22, +0x2c, 0x9e, 0x82, 0x08, 0x43, 0x44, 0xaf, 0xe1, 0x4d, 0xbf, 0xae, 0xdf, +0xf1, 0xaf, 0x79, 0x11, 0x8f, 0xca, 0x28, 0xf9, 0xf3, 0x03, 0x89, 0x70, +0x4e, 0x63, 0x03, 0x00, 0xe4, 0x10, 0x07, 0xf1, 0x12, 0x24, 0x9c, 0xf4, +0xfb, 0xf7, 0xef, 0x87, 0x38, 0xc4, 0x4a, 0x4c, 0xab, 0xe9, 0xd7, 0x35, +0x42, 0xa1, 0x2c, 0x47, 0xbf, 0x97, 0xf7, 0x74, 0x00, 0x00, 0x20, 0x21, +0x77, 0x15, 0x07, 0x59, 0xbc, 0x53, 0x89, 0x83, 0x7a, 0x10, 0x2a, 0x40, +0xf2, 0xab, 0xb9, 0x9b, 0xba, 0x74, 0xb2, 0x1b, 0x00, 0x00, 0xb6, 0x3c, +0x07, 0x15, 0x07, 0xc9, 0x37, 0xc4, 0x16, 0x86, 0xd0, 0xf4, 0xfb, 0x89, +0x48, 0x5c, 0x10, 0x22, 0x0e, 0xdb, 0x01, 0x00, 0xa4, 0xf6, 0x1c, 0xd4, +0x6b, 0x88, 0x91, 0x88, 0x3e, 0x22, 0x12, 0xea, 0x49, 0x38, 0xce, 0x52, +0x00, 0x00, 0x54, 0xc3, 0xe3, 0x22, 0x1f, 0x09, 0xf9, 0xe8, 0x22, 0x9d, +0x22, 0xa4, 0xb4, 0x57, 0x24, 0x4e, 0x78, 0x2d, 0x54, 0x2f, 0x01, 0x00, +0xa4, 0x40, 0xe2, 0xf7, 0xd6, 0x73, 0xc8, 0x2d, 0x0c, 0xd6, 0x44, 0x1c, +0xe4, 0x73, 0xec, 0xf5, 0x5e, 0x0e, 0x96, 0xca, 0x02, 0x00, 0xc0, 0x01, +0x16, 0xcd, 0x01, 0x94, 0x16, 0x07, 0x35, 0xcd, 0x47, 0x38, 0x72, 0x0f, +0x00, 0x00, 0x45, 0x98, 0xd4, 0x73, 0xd0, 0x84, 0x74, 0x89, 0xb0, 0x92, +0xdb, 0xa8, 0x6e, 0xda, 0xf3, 0x79, 0xa8, 0x5c, 0x02, 0x00, 0x88, 0x8b, +0xf6, 0x2b, 0x7a, 0x5f, 0x88, 0xc5, 0x62, 0x1e, 0x80, 0x8b, 0xe5, 0x45, +0x3c, 0xcb, 0x45, 0xf8, 0x73, 0x0f, 0x24, 0xa6, 0x01, 0x00, 0x2e, 0x0a, +0xc2, 0xa3, 0x4d, 0x85, 0xb6, 0xa8, 0xb0, 0x07, 0xe0, 0x52, 0x9e, 0x73, +0x70, 0x17, 0x13, 0xd6, 0x5b, 0x61, 0x26, 0xaa, 0x96, 0x00, 0x00, 0x5e, +0x2f, 0xfc, 0xba, 0xf8, 0x6b, 0x9f, 0xa2, 0xf7, 0x5e, 0x45, 0xda, 0xa2, +0x42, 0xdb, 0x54, 0x68, 0xf7, 0x55, 0x0d, 0x27, 0x59, 0xcb, 0x71, 0xd6, +0xc1, 0x9d, 0x4c, 0x58, 0x6f, 0x08, 0xd7, 0xc4, 0xeb, 0x07, 0x00, 0x44, +0xc0, 0x2c, 0xfa, 0xba, 0xe0, 0xeb, 0xa2, 0x6f, 0x17, 0x4f, 0x11, 0x00, +0x6b, 0x12, 0x32, 0x12, 0x93, 0x45, 0x56, 0x4c, 0x76, 0xe3, 0x62, 0xfa, +0xdf, 0xfa, 0xfb, 0xb1, 0x1a, 0xef, 0xa5, 0xb2, 0x15, 0x81, 0x20, 0x29, +0x0d, 0x00, 0x43, 0x32, 0x87, 0x3b, 0xff, 0xb5, 0xd0, 0xcb, 0x56, 0x48, +0x46, 0x4c, 0x85, 0xa3, 0xb6, 0x90, 0xd1, 0x59, 0x71, 0x08, 0x7e, 0x5e, +0xc4, 0x01, 0x00, 0xc6, 0x14, 0x85, 0xd6, 0x17, 0xf4, 0x54, 0x22, 0xe1, +0xc5, 0x0e, 0x71, 0x00, 0x80, 0x71, 0x42, 0x47, 0x88, 0x02, 0x7d, 0x96, +0x00, 0x00, 0x84, 0xc9, 0x99, 0x5c, 0x02, 0x8b, 0x3e, 0xad, 0x34, 0x00, +0x60, 0x5c, 0xde, 0x6f, 0x40, 0xd3, 0x84, 0xb1, 0xe6, 0x09, 0x58, 0xf0, +0x69, 0xe5, 0x0d, 0x90, 0x32, 0x3c, 0x71, 0xc5, 0x20, 0x83, 0x20, 0x48, +0x75, 0x90, 0xfd, 0xb5, 0x87, 0xa4, 0xb1, 0x8b, 0x78, 0xc6, 0xc1, 0x3e, +0x13, 0xfd, 0x7f, 0x47, 0xb7, 0x56, 0x80, 0xdd, 0x8b, 0xcd, 0xa4, 0x0b, +0x8e, 0x0d, 0x4d, 0xd8, 0x2a, 0x95, 0x33, 0x66, 0x4b, 0x25, 0xcd, 0x25, +0xef, 0x8b, 0xb1, 0xd9, 0xd8, 0x64, 0x0c, 0x81, 0xd9, 0x78, 0x47, 0xf2, +0x0c, 0x6d, 0x29, 0xa9, 0x18, 0xa2, 0xf0, 0xbc, 0x8d, 0x86, 0x6d, 0xa5, +0xa1, 0xcf, 0x0e, 0x81, 0x00, 0x76, 0xff, 0x7f, 0x17, 0xdc, 0xd9, 0x0a, +0x80, 0xab, 0x3c, 0x3e, 0x1d, 0x0a, 0x4c, 0x20, 0x2c, 0xf3, 0x86, 0xb0, +0xf4, 0x24, 0x2a, 0x9f, 0x3c, 0x04, 0x59, 0xd4, 0xb4, 0xc9, 0x5d, 0xed, +0xe7, 0x09, 0x5c, 0x25, 0x27, 0xa3, 0xc3, 0xd3, 0xdb, 0xf6, 0xb2, 0x20, +0xc7, 0x75, 0xa2, 0x30, 0x18, 0xef, 0x5e, 0xc0, 0x81, 0x8b, 0xd7, 0xbb, +0x2b, 0x51, 0x0c, 0x04, 0xc5, 0x8a, 0xc8, 0xbd, 0x72, 0x11, 0xf9, 0xe4, +0x21, 0xd8, 0x05, 0x4e, 0x3d, 0x05, 0x04, 0xe0, 0xb5, 0xd7, 0xa0, 0x42, +0x1a, 0x9e, 0xde, 0x56, 0x8f, 0xe2, 0xd9, 0x69, 0x6e, 0x72, 0x10, 0xd0, +0x8b, 0x77, 0xf0, 0xde, 0xf3, 0x86, 0x4a, 0x95, 0x73, 0x9e, 0xc9, 0x86, +0x77, 0xa2, 0x62, 0x92, 0x5a, 0x50, 0x34, 0x6c, 0xb4, 0xac, 0xb5, 0xa6, +0xc0, 0x53, 0x38, 0xfe, 0x6e, 0xad, 0xa8, 0x5a, 0xa1, 0xd0, 0xcd, 0x92, +0xfe, 0xf9, 0x8e, 0xc6, 0x7c, 0x00, 0x4d, 0xc6, 0xa0, 0x17, 0x6d, 0x82, +0xe6, 0x3e, 0x1f, 0xee, 0x61, 0xa1, 0xb8, 0x70, 0x82, 0x56, 0x93, 0x97, +0xda, 0x12, 0x42, 0xab, 0x81, 0xc4, 0x02, 0x8f, 0x24, 0x14, 0x90, 0xa3, +0x21, 0xbf, 0x59, 0xbf, 0xee, 0x96, 0x97, 0xc0, 0xfb, 0xbc, 0x26, 0x0e, +0x6b, 0x97, 0x00, 0xc9, 0xdf, 0x51, 0x01, 0x7e, 0x26, 0xba, 0x08, 0x04, +0x34, 0x15, 0x87, 0x0e, 0x05, 0x01, 0xcb, 0x2f, 0x1c, 0xfa, 0xdf, 0x6b, +0x02, 0xa2, 0xd7, 0x67, 0xca, 0x7b, 0xd2, 0x5f, 0x55, 0x50, 0xf4, 0xbf, +0xc3, 0x3c, 0x82, 0x5d, 0xc8, 0xe4, 0xf7, 0xf0, 0x12, 0xe2, 0x5c, 0x1f, +0x6a, 0x2d, 0x0c, 0xc7, 0xe9, 0xed, 0x71, 0xaf, 0x04, 0x82, 0x24, 0x35, +0xd4, 0x2e, 0x0a, 0x0b, 0x21, 0xa3, 0xf6, 0x3c, 0x8f, 0xb5, 0x64, 0x72, +0xb8, 0x68, 0x85, 0x5d, 0x4d, 0x11, 0x86, 0x34, 0x15, 0x4b, 0x2a, 0xbc, +0xf6, 0xcf, 0xd5, 0xc3, 0x78, 0x75, 0x93, 0x1d, 0x02, 0x01, 0xb5, 0x31, +0xe1, 0x25, 0xf4, 0x99, 0xeb, 0xb0, 0x5e, 0x87, 0xed, 0x70, 0x8a, 0x30, +0xe4, 0xa9, 0x5e, 0x0a, 0x93, 0xd3, 0x6b, 0xc2, 0x81, 0x40, 0x40, 0xb5, +0xa2, 0x80, 0xa7, 0x80, 0x61, 0xe9, 0x2a, 0x99, 0xd4, 0x63, 0x38, 0x72, +0x1f, 0x05, 0x39, 0x08, 0x28, 0x16, 0x3e, 0x42, 0x14, 0x30, 0x2c, 0x6f, +0x08, 0xd0, 0x86, 0xfd, 0xe4, 0xd7, 0x57, 0x9e, 0xba, 0xff, 0x73, 0x80, +0x6c, 0xdc, 0x7c, 0xd2, 0x92, 0x89, 0x8b, 0x61, 0x0d, 0x08, 0x0b, 0x21, +0x26, 0xc8, 0x22, 0x0c, 0x7f, 0x6c, 0x21, 0xb7, 0x80, 0x61, 0xb4, 0xfc, +0x06, 0xf8, 0x20, 0x0c, 0x84, 0x92, 0x30, 0xac, 0x4d, 0xf3, 0x73, 0x17, +0x2f, 0x02, 0xea, 0x16, 0x86, 0x95, 0x6b, 0x10, 0x31, 0x0c, 0xc3, 0x8b, +0x80, 0xc6, 0x98, 0x62, 0x09, 0x83, 0x96, 0x46, 0xda, 0x3b, 0x7f, 0x99, +0xac, 0x18, 0x56, 0x24, 0x17, 0x71, 0x67, 0x69, 0x83, 0x4b, 0xc2, 0x10, +0x2b, 0x01, 0x6d, 0x4f, 0xe9, 0x22, 0x0a, 0x18, 0x46, 0xa8, 0x09, 0xf0, +0x18, 0x1e, 0x62, 0xa0, 0xa5, 0x78, 0x84, 0x93, 0x30, 0x8c, 0x2b, 0x48, +0xa1, 0xf1, 0x3c, 0x43, 0xac, 0xc1, 0xa7, 0xfd, 0xe9, 0x69, 0xe3, 0x8c, +0x61, 0xe4, 0x23, 0xa0, 0x71, 0xaf, 0x21, 0x66, 0xe8, 0x47, 0x8f, 0xff, +0x23, 0x0e, 0x18, 0xc6, 0xd9, 0x08, 0x68, 0x9b, 0x25, 0xe6, 0x80, 0xd3, +0xce, 0x92, 0x88, 0x03, 0x86, 0x21, 0x10, 0xd0, 0x2e, 0xf7, 0x98, 0xa7, +0xa0, 0x35, 0xdf, 0xf0, 0xaa, 0xe5, 0x30, 0x86, 0x61, 0x84, 0x98, 0x60, +0x90, 0x5c, 0x83, 0x0b, 0x2e, 0x35, 0xc1, 0x73, 0xc0, 0xb0, 0xa6, 0x6c, +0x62, 0x49, 0x84, 0x77, 0xaf, 0x21, 0x45, 0x99, 0xa9, 0x8a, 0xc3, 0xab, +0x76, 0xc3, 0x18, 0x86, 0x21, 0x10, 0x30, 0x40, 0xae, 0x21, 0x4c, 0x48, +0xdb, 0xfb, 0x71, 0x31, 0x0c, 0x6b, 0xc6, 0x38, 0x30, 0x37, 0x38, 0x53, +0xaa, 0xde, 0x49, 0xf6, 0x2e, 0xdc, 0x57, 0xbd, 0xe8, 0x31, 0x0c, 0xe3, +0x1c, 0x04, 0x0c, 0xe0, 0x35, 0xb8, 0xa0, 0x62, 0x09, 0xef, 0x01, 0xc3, +0xda, 0x32, 0x5f, 0xa0, 0x02, 0x78, 0x0d, 0xe9, 0x4c, 0x73, 0x0f, 0x78, +0x0f, 0x18, 0x86, 0xe7, 0x00, 0x0d, 0x24, 0xa1, 0x73, 0xdd, 0x01, 0x2d, +0xa5, 0xac, 0x7a, 0xd5, 0x21, 0x65, 0xad, 0x18, 0xd6, 0xcc, 0x99, 0x07, +0xca, 0x5a, 0x07, 0x24, 0xcb, 0x05, 0x3e, 0x3a, 0xc0, 0x44, 0x84, 0x34, +0xbc, 0x84, 0xf7, 0x80, 0x75, 0xbe, 0xa0, 0xf6, 0xd4, 0x9c, 0x6f, 0x62, +0xa9, 0x1c, 0xcc, 0x63, 0x70, 0x99, 0x6e, 0x76, 0xf3, 0x31, 0xcb, 0x47, +0xc5, 0x83, 0x0c, 0x36, 0x4d, 0x4e, 0xe3, 0x3d, 0x60, 0xbd, 0x8a, 0x43, +0x2f, 0x67, 0x7a, 0x68, 0xef, 0x8d, 0x30, 0xa4, 0xde, 0x79, 0x58, 0xb7, +0xf4, 0xa6, 0xd5, 0x4b, 0x62, 0x2c, 0x26, 0x58, 0x8f, 0xa6, 0x77, 0x97, +0xa4, 0x9c, 0x57, 0xb2, 0xe9, 0x12, 0x4b, 0x99, 0x2f, 0x44, 0x1c, 0x06, +0x0c, 0x25, 0xe5, 0x9a, 0x24, 0xde, 0x6b, 0x08, 0xfb, 0xb4, 0x3c, 0x0e, +0xdb, 0x71, 0x30, 0x0e, 0xeb, 0xd9, 0xf4, 0x62, 0xab, 0x84, 0xa1, 0x9e, +0x70, 0x5e, 0x4d, 0x1a, 0xbe, 0x95, 0xbf, 0x13, 0x63, 0xf3, 0x47, 0xce, +0x61, 0x2c, 0xe6, 0x5c, 0x77, 0x41, 0xbf, 0x18, 0x58, 0x93, 0x0a, 0x04, +0xf9, 0x07, 0xac, 0x57, 0x93, 0xcd, 0x4f, 0x4c, 0x0f, 0xc2, 0xcf, 0xa9, +0x23, 0xd5, 0x43, 0xf7, 0x2b, 0x82, 0xc1, 0x85, 0x40, 0x08, 0x43, 0xa9, +0x64, 0xd6, 0xa4, 0x15, 0x4c, 0xf4, 0x5d, 0xc2, 0x7a, 0xcd, 0x3f, 0x88, +0x40, 0x44, 0x0e, 0xe1, 0x5e, 0x4d, 0x10, 0xdf, 0xfc, 0xd7, 0x58, 0x54, +0x34, 0x54, 0x38, 0x34, 0x54, 0xe5, 0x3d, 0xfe, 0x85, 0x64, 0xf4, 0x18, +0xa1, 0xa4, 0xac, 0xc2, 0xf0, 0x24, 0xa4, 0xf4, 0x49, 0x20, 0xb4, 0xbd, +0x06, 0x09, 0x6a, 0xac, 0xd7, 0xf0, 0x52, 0xe4, 0xf0, 0x29, 0x61, 0x1e, +0x88, 0x96, 0x7c, 0x9e, 0x73, 0x97, 0xd7, 0x1d, 0x8c, 0x55, 0xce, 0x2a, +0x10, 0x9c, 0x9e, 0xc6, 0x7a, 0x0d, 0x2f, 0x45, 0x0c, 0x9f, 0x22, 0x0e, +0x70, 0x99, 0x29, 0xe6, 0xdd, 0x0c, 0x27, 0x42, 0x4a, 0x47, 0xaa, 0x1c, +0x16, 0x11, 0x08, 0x2a, 0x98, 0xb0, 0x1e, 0x4d, 0xc3, 0xa7, 0x91, 0xbc, +0x63, 0xc4, 0x01, 0xae, 0xc5, 0x14, 0x73, 0x87, 0x91, 0x4e, 0x84, 0x94, +0x3e, 0x09, 0x84, 0xec, 0xae, 0x10, 0x08, 0xac, 0x47, 0xd3, 0x03, 0xa0, +0x11, 0xbe, 0x16, 0xed, 0x2c, 0xe0, 0x7c, 0x7e, 0xa1, 0x64, 0x78, 0xe6, +0x62, 0xf9, 0xdb, 0x12, 0xd9, 0x05, 0xc7, 0xb0, 0xaa, 0xbc, 0x87, 0xab, +0x9b, 0x1f, 0xae, 0xf1, 0x84, 0xb3, 0xc2, 0xb0, 0x94, 0x8e, 0xdb, 0x9f, +0x08, 0x29, 0xad, 0x7a, 0x10, 0x54, 0x30, 0x61, 0xbd, 0x7a, 0x0f, 0x57, +0xc6, 0x36, 0x07, 0xd3, 0xe0, 0x28, 0xd9, 0x1a, 0xe8, 0x65, 0x72, 0x7b, +0x87, 0x12, 0x08, 0xd9, 0x55, 0x52, 0xad, 0x35, 0x46, 0x69, 0xab, 0x76, +0x07, 0x38, 0x3b, 0x57, 0x11, 0x07, 0x68, 0x52, 0x18, 0x22, 0x78, 0x0d, +0x1f, 0x04, 0x42, 0xc4, 0x01, 0x81, 0xc0, 0x7a, 0xf4, 0x1e, 0xce, 0x86, +0x4e, 0xfd, 0x3c, 0x9f, 0x58, 0xf6, 0xe0, 0x15, 0x73, 0xa9, 0x8a, 0xa4, +0x27, 0x5e, 0x43, 0xcc, 0x78, 0xe8, 0x92, 0xaa, 0x0d, 0x41, 0x8d, 0x36, +0xd2, 0xcf, 0x4a, 0xee, 0xe1, 0x9c, 0xf7, 0x80, 0x38, 0xc0, 0x4b, 0x6f, +0x41, 0x16, 0xce, 0x92, 0x15, 0x49, 0x2e, 0x5f, 0x7b, 0xdf, 0x79, 0x24, +0x0f, 0x82, 0x7c, 0x4b, 0xff, 0xa6, 0x9d, 0x89, 0x2f, 0xbc, 0x67, 0xc4, +0x01, 0x9a, 0xf0, 0x16, 0xd6, 0xba, 0xaf, 0xc6, 0x66, 0x4a, 0xdd, 0xe9, +0xb2, 0xb6, 0xb8, 0x34, 0x1e, 0x44, 0xff, 0xa1, 0xa5, 0x0b, 0x27, 0xa7, +0x11, 0x07, 0xa8, 0xdb, 0x5b, 0xc8, 0x24, 0x0c, 0xef, 0x3f, 0xbf, 0x2c, +0x98, 0x23, 0x94, 0xb9, 0xca, 0xcf, 0xc9, 0x7d, 0xdb, 0x63, 0x84, 0x96, +0x4e, 0x6e, 0x02, 0x38, 0x08, 0x07, 0x0f, 0xde, 0x1b, 0x65, 0xd5, 0xb6, +0x58, 0x98, 0x2e, 0x91, 0xb9, 0xea, 0xae, 0x6f, 0xda, 0xcc, 0x6c, 0x84, +0xfc, 0x03, 0x07, 0x02, 0xfb, 0xf6, 0x0e, 0x2f, 0x84, 0x96, 0x38, 0x08, +0x87, 0xa7, 0xf0, 0x6f, 0x08, 0xa9, 0xd6, 0x1d, 0xa4, 0xbd, 0xe5, 0x2d, +0x27, 0xe2, 0xad, 0x88, 0x40, 0xf4, 0x1e, 0x7a, 0xe1, 0xc4, 0x78, 0xdf, +0x9e, 0xe1, 0x85, 0xaa, 0x25, 0xc4, 0x61, 0x64, 0x51, 0xa8, 0xd1, 0x53, +0x70, 0x79, 0x12, 0xd0, 0xbb, 0xd0, 0x3b, 0xa9, 0x7b, 0xcf, 0x43, 0x88, +0x08, 0x22, 0x10, 0xfd, 0x8a, 0xc3, 0x49, 0x2f, 0x98, 0xb0, 0xd2, 0x80, +0x4c, 0x35, 0x7b, 0x0a, 0x05, 0xf2, 0x0c, 0x2f, 0x9f, 0x57, 0x4f, 0x77, +0xf6, 0x6e, 0x85, 0x20, 0xb8, 0x14, 0x09, 0xcf, 0x21, 0x08, 0xe3, 0x4e, +0x2c, 0x95, 0x83, 0x79, 0x0c, 0xb5, 0x55, 0x21, 0xb9, 0x38, 0xb7, 0x51, +0x65, 0x09, 0x33, 0xf5, 0x1c, 0x62, 0xe2, 0x52, 0xa4, 0x7e, 0xc5, 0xe1, +0xc8, 0x3b, 0x3d, 0xd9, 0xd0, 0x12, 0x1a, 0x0e, 0x21, 0xc9, 0x2e, 0xa0, +0xba, 0x2a, 0xa4, 0x27, 0x1e, 0xc3, 0x52, 0xe9, 0x00, 0xbd, 0xf7, 0x5c, +0xdd, 0xa3, 0xe5, 0x8f, 0x94, 0xb8, 0x8e, 0xe9, 0x39, 0x94, 0x0e, 0xe3, +0x42, 0x1e, 0x6e, 0x9a, 0x57, 0x68, 0x41, 0x10, 0x2a, 0x0c, 0x25, 0xed, +0x0a, 0x35, 0xf5, 0xb8, 0xa8, 0xe8, 0x82, 0x42, 0x89, 0x6b, 0xfb, 0x95, +0x68, 0xf2, 0x1e, 0x8f, 0x88, 0x03, 0x5e, 0x43, 0xff, 0x5e, 0xc2, 0xdc, +0x42, 0x4e, 0xa1, 0x61, 0x61, 0xb8, 0xe9, 0x33, 0xee, 0x31, 0x04, 0xa3, +0x8b, 0x0a, 0x09, 0xea, 0x3e, 0xbc, 0xc0, 0xbd, 0x09, 0xe9, 0x8b, 0x6d, +0xf0, 0xa1, 0x72, 0x96, 0x56, 0x77, 0x7b, 0x15, 0x0e, 0xcc, 0xc7, 0xb9, +0x0f, 0xbd, 0x1c, 0xdd, 0x5c, 0x86, 0xfe, 0x2e, 0xbc, 0x7a, 0x46, 0xa0, +0xc7, 0x30, 0x4c, 0x84, 0xd3, 0xb5, 0x58, 0xe1, 0xf9, 0x24, 0xef, 0x4e, +0xc5, 0x61, 0x8f, 0xd0, 0xd3, 0x89, 0xb5, 0x6f, 0xe6, 0xc6, 0x85, 0xa1, +0x36, 0x77, 0xf6, 0x71, 0xd3, 0x9d, 0x88, 0x80, 0x2c, 0x96, 0x6a, 0xda, +0xb8, 0x4e, 0x4d, 0x2f, 0x77, 0xef, 0xa9, 0x1d, 0x85, 0x26, 0xa7, 0x49, +0x50, 0xb7, 0x9f, 0x6f, 0xd8, 0xdb, 0x80, 0x8f, 0x90, 0x52, 0xe7, 0xb4, +0x50, 0x89, 0xd4, 0x88, 0x30, 0x3c, 0xbc, 0x07, 0x3d, 0x08, 0xa7, 0x13, +0x4c, 0x9b, 0xf3, 0xa9, 0x40, 0x84, 0x13, 0x4e, 0xc5, 0xa2, 0x87, 0x78, +0xbd, 0x7a, 0x0f, 0xb4, 0xd8, 0x68, 0x5f, 0x1c, 0x64, 0x0c, 0x3f, 0x7b, +0x87, 0x84, 0x94, 0x10, 0x88, 0x5a, 0xcb, 0x55, 0x6b, 0xde, 0xad, 0x2c, +0x67, 0x6f, 0xd6, 0xea, 0x61, 0x41, 0xd5, 0x05, 0x86, 0xfc, 0x43, 0xdb, +0xe2, 0xf0, 0x2c, 0x21, 0xdd, 0xc8, 0x3c, 0x84, 0x51, 0x04, 0xc2, 0x24, +0x9f, 0x6b, 0x1f, 0x90, 0x0f, 0xef, 0x41, 0x6f, 0xd6, 0x1a, 0x6d, 0x91, +0xb1, 0x15, 0x2f, 0xe4, 0x1f, 0xda, 0xeb, 0x99, 0x65, 0x3d, 0xde, 0x9d, +0x1b, 0x35, 0x18, 0x84, 0xa5, 0x36, 0x4f, 0xc1, 0x24, 0x76, 0xa7, 0x86, +0x9e, 0xe3, 0x7d, 0xe4, 0x03, 0x62, 0x36, 0xb1, 0x49, 0xfe, 0xa1, 0x3d, +0x51, 0x3f, 0x9a, 0x0b, 0xe3, 0xac, 0xc3, 0x38, 0xdc, 0x4a, 0x9f, 0x73, +0x30, 0xa2, 0x20, 0x9e, 0x42, 0xab, 0xd5, 0x10, 0x93, 0x4e, 0xb8, 0xd1, +0x0e, 0x88, 0x85, 0x0b, 0x0d, 0x8b, 0x6f, 0x5b, 0x95, 0x4a, 0x12, 0x52, +0xba, 0x70, 0x1b, 0x1c, 0x79, 0x88, 0x01, 0xc8, 0x7e, 0xb2, 0xb7, 0x13, +0x51, 0x58, 0x15, 0x88, 0xd1, 0x12, 0xb4, 0xe1, 0x62, 0xc3, 0x22, 0xdc, +0x4e, 0xbe, 0x21, 0x92, 0xb7, 0x87, 0x48, 0x0c, 0x40, 0xf2, 0x93, 0xbd, +0xe6, 0x5c, 0xc0, 0xd4, 0x61, 0x92, 0x6b, 0x48, 0x81, 0xb8, 0x12, 0xa6, +0xc0, 0xba, 0x7a, 0x57, 0x84, 0x9b, 0x46, 0x10, 0x89, 0x98, 0xe1, 0x26, +0x59, 0x28, 0x4d, 0x4f, 0xa4, 0xde, 0x07, 0xd0, 0xbb, 0x40, 0x8c, 0xb4, +0xe8, 0xec, 0xad, 0x7e, 0xc1, 0xca, 0x7a, 0x0d, 0xd6, 0xcb, 0x7b, 0x55, +0xc2, 0x7a, 0x76, 0xf3, 0xc7, 0xf2, 0x39, 0x48, 0x4e, 0xc2, 0x9d, 0x6c, +0xc8, 0x17, 0x9e, 0x1c, 0x76, 0x63, 0x95, 0xc2, 0xdd, 0x34, 0x49, 0x3d, +0xca, 0x2e, 0xda, 0xb6, 0x63, 0xd0, 0x9f, 0xfb, 0xd9, 0x99, 0x0f, 0xac, +0xee, 0x12, 0xd6, 0x08, 0x46, 0x75, 0xd3, 0x68, 0x1e, 0x85, 0xbc, 0x74, +0x6d, 0x1b, 0x11, 0x5a, 0x20, 0x06, 0x23, 0x1f, 0xb5, 0xbf, 0x69, 0xb9, +0xf0, 0x9e, 0x52, 0xc1, 0x5e, 0xbd, 0x07, 0x1b, 0xc2, 0xd0, 0x30, 0x86, +0xec, 0x56, 0xc5, 0xf4, 0xcf, 0x11, 0x8f, 0x72, 0x02, 0x9e, 0xc3, 0xc3, +0xf3, 0xf3, 0x00, 0x00, 0x54, 0x1c, 0xac, 0xb7, 0x25, 0x93, 0x70, 0x94, +0x3b, 0xa7, 0x43, 0xef, 0xc1, 0x0a, 0xc6, 0x2b, 0x53, 0xf1, 0x58, 0x6b, +0x43, 0xd2, 0x92, 0x78, 0xc8, 0x67, 0x7d, 0x65, 0xae, 0x70, 0xe1, 0x40, +0x81, 0xd2, 0x63, 0x3c, 0x09, 0x00, 0x41, 0xc5, 0x41, 0x17, 0x82, 0x11, +0xc2, 0x4c, 0xf6, 0xd2, 0x7a, 0xdd, 0x99, 0x6a, 0x9c, 0x5b, 0xfb, 0x4b, +0xa9, 0xed, 0x15, 0x8c, 0x2d, 0x01, 0x51, 0x11, 0x59, 0x13, 0x92, 0x23, +0x8b, 0xb4, 0x35, 0xfb, 0x35, 0x6c, 0x6f, 0xac, 0xb0, 0x7f, 0xd6, 0x96, +0xd9, 0x9f, 0x71, 0xef, 0xcf, 0xb2, 0xe5, 0x4d, 0xa5, 0x10, 0x10, 0xbd, +0xd1, 0xaf, 0xf0, 0xb9, 0x14, 0x44, 0x02, 0x86, 0x67, 0xd9, 0xda, 0xbd, +0xf5, 0xec, 0x45, 0x84, 0xdd, 0x3e, 0xfd, 0x22, 0x77, 0xf3, 0xf6, 0x21, +0x2c, 0xb9, 0xb6, 0xf8, 0x86, 0x22, 0x72, 0x45, 0x4c, 0xae, 0x88, 0x50, +0x2c, 0x5b, 0xfb, 0x59, 0x5e, 0x89, 0x9b, 0x86, 0x69, 0x53, 0x08, 0x84, +0x6d, 0x9a, 0x58, 0xf8, 0x5c, 0x0a, 0x22, 0x01, 0xc3, 0x32, 0xbb, 0x17, +0x89, 0xc1, 0x1e, 0xbd, 0x88, 0x30, 0x74, 0xe1, 0x7f, 0xc6, 0x3d, 0x75, +0xf0, 0x56, 0x40, 0x66, 0xbf, 0x78, 0x2c, 0x56, 0x4c, 0xec, 0xee, 0x3e, +0x14, 0x94, 0x2d, 0xbb, 0xea, 0xa9, 0x1c, 0x35, 0xf9, 0x9e, 0x1a, 0x06, +0x0b, 0xc3, 0x48, 0xf6, 0xff, 0x4d, 0xf5, 0x9e, 0xe6, 0xe8, 0x26, 0xf3, +0x0c, 0x3e, 0x79, 0xa0, 0xa9, 0xc2, 0x7f, 0x29, 0x2a, 0x96, 0x0e, 0x1a, +0x67, 0x24, 0x60, 0x38, 0x5e, 0x9e, 0x19, 0xe9, 0x31, 0x17, 0xb1, 0x96, +0xf4, 0x8c, 0x9c, 0x94, 0xd4, 0x05, 0xf4, 0x6e, 0x6c, 0x7a, 0x61, 0x9f, +0xc4, 0x66, 0xcd, 0xc2, 0x50, 0xd2, 0x96, 0xe9, 0xdf, 0xdb, 0xfa, 0x3a, +0xf6, 0x7b, 0x05, 0x9f, 0x43, 0x3f, 0xef, 0x27, 0x11, 0xd8, 0x13, 0xa2, +0x4c, 0xf5, 0x9e, 0x7c, 0x78, 0x69, 0x2a, 0xdc, 0x2d, 0x01, 0x91, 0x00, +0xc4, 0x61, 0x2d, 0x4e, 0xdf, 0x4b, 0x45, 0x53, 0x28, 0x0e, 0x26, 0xb4, +0xd4, 0x4a, 0xf5, 0xda, 0xed, 0xa0, 0x65, 0xcd, 0x61, 0xb9, 0x04, 0xd5, +0x65, 0x2b, 0xe1, 0xbf, 0x92, 0x17, 0x83, 0x4d, 0x2c, 0x1d, 0xd0, 0x3b, +0xb7, 0x23, 0x13, 0xac, 0x87, 0x93, 0xd5, 0x61, 0xdf, 0x9e, 0xe0, 0x14, +0x2e, 0x3b, 0xc3, 0xeb, 0x44, 0x6d, 0x96, 0x69, 0xf3, 0x0f, 0xf2, 0xde, +0x56, 0x3c, 0xbc, 0x7b, 0x89, 0x2b, 0x85, 0x8d, 0x50, 0x01, 0xf4, 0xc9, +0x99, 0xd6, 0xe8, 0xb2, 0xf3, 0x6e, 0xb5, 0x81, 0xdd, 0x5a, 0xe9, 0xaa, +0x11, 0x07, 0x12, 0x90, 0x71, 0x98, 0x5d, 0x22, 0x81, 0xf0, 0xde, 0xeb, +0x96, 0x87, 0x77, 0xcf, 0x1d, 0x7a, 0xe2, 0x8c, 0x04, 0x30, 0x91, 0x37, +0x42, 0x4d, 0x2d, 0xe5, 0x23, 0xe4, 0x33, 0x87, 0x21, 0xa5, 0x15, 0x71, +0x60, 0x37, 0x18, 0x87, 0x7b, 0x8a, 0x50, 0xa0, 0xbc, 0xab, 0x9d, 0xed, +0x2f, 0xe4, 0x3d, 0xce, 0x19, 0x3d, 0x0a, 0xbc, 0x4e, 0x18, 0x3b, 0xb4, +0xb4, 0xb5, 0xab, 0xab, 0xbd, 0x57, 0x91, 0x7c, 0x4e, 0xf5, 0x78, 0xd6, +0xaa, 0x77, 0x68, 0xef, 0x9c, 0x86, 0x98, 0xbb, 0x78, 0x7d, 0x77, 0x1b, +0xe1, 0xa5, 0x57, 0x42, 0x95, 0xfc, 0x6e, 0x18, 0x42, 0x4d, 0x40, 0x68, +0xe9, 0x49, 0x3e, 0xa2, 0xa6, 0xd2, 0x57, 0x99, 0xac, 0xf2, 0xb9, 0xb4, +0x5c, 0xf4, 0x59, 0x69, 0x27, 0xe2, 0x90, 0x94, 0xc5, 0x45, 0x3e, 0x20, +0xa7, 0xd5, 0x4b, 0x27, 0x3d, 0x9a, 0xd4, 0xc9, 0x6c, 0xc2, 0x93, 0xd0, +0x0d, 0x93, 0x8b, 0x78, 0x86, 0xc0, 0x54, 0x96, 0x64, 0x13, 0x81, 0xad, +0x73, 0x05, 0xaf, 0xce, 0x0f, 0xc8, 0xdf, 0x91, 0x7f, 0x67, 0x5a, 0xb4, +0x43, 0x45, 0xe1, 0xcb, 0xad, 0x4d, 0xc8, 0x81, 0xf0, 0x52, 0x11, 0x8f, +0x02, 0x2f, 0x02, 0x70, 0xff, 0x9f, 0x88, 0x44, 0xcc, 0x7c, 0xc4, 0x96, +0x00, 0x1c, 0x3d, 0x40, 0x16, 0x9e, 0xfe, 0xd5, 0xd3, 0xbe, 0x78, 0x0d, +0x59, 0x88, 0x92, 0x87, 0xb0, 0xf9, 0x87, 0x88, 0x09, 0xe1, 0x54, 0xf9, +0x09, 0xc6, 0x15, 0xe0, 0x3d, 0xb8, 0x8d, 0x04, 0x70, 0xcc, 0xf3, 0x11, +0x7a, 0x72, 0xd7, 0x0a, 0xc5, 0xb3, 0xd3, 0xc7, 0x61, 0xfb, 0x07, 0x7b, +0xfa, 0xb7, 0xd1, 0xfb, 0xc0, 0x5b, 0xe7, 0x16, 0x63, 0x11, 0x56, 0x81, +0xf0, 0x1b, 0x90, 0x98, 0x61, 0x9c, 0x5b, 0x8c, 0x30, 0xab, 0xa3, 0xa2, +0x09, 0x7a, 0x22, 0xf6, 0xa4, 0x08, 0x3d, 0x89, 0x58, 0xf9, 0x08, 0x93, +0x1f, 0xb8, 0xfb, 0x5f, 0xdf, 0x4f, 0x14, 0xdb, 0xc5, 0x5f, 0x05, 0x20, +0x10, 0x81, 0xec, 0x87, 0xc3, 0x20, 0xcd, 0x58, 0xd3, 0xf3, 0x2a, 0xbe, +0x18, 0x22, 0x85, 0xc0, 0xcf, 0x8e, 0xc3, 0x73, 0x00, 0x69, 0xbc, 0x07, +0x17, 0xc4, 0x8b, 0x63, 0xf6, 0xc9, 0x79, 0x72, 0xaa, 0x99, 0xc5, 0xbf, +0x0d, 0x2e, 0xc7, 0xfb, 0x35, 0xa4, 0xe8, 0x37, 0x1e, 0xa9, 0xde, 0x79, +0xcc, 0x90, 0x13, 0xc9, 0x6a, 0xc0, 0x7b, 0x78, 0x16, 0x12, 0x88, 0x59, +0xfa, 0xea, 0x3f, 0x33, 0x62, 0xd0, 0x26, 0x97, 0x77, 0xe7, 0x2a, 0x10, +0x19, 0xae, 0xff, 0xbc, 0xc7, 0x98, 0x1f, 0x24, 0xab, 0x01, 0xef, 0x61, +0x87, 0x48, 0x44, 0xee, 0xd7, 0xc4, 0xae, 0x6c, 0xc0, 0x31, 0xa7, 0x67, +0x6d, 0x22, 0x55, 0x30, 0xe5, 0x0c, 0x39, 0x91, 0xac, 0x86, 0xf1, 0xdc, +0x7d, 0xb7, 0x3f, 0x6f, 0xb0, 0x24, 0xc8, 0x47, 0xdc, 0x79, 0x85, 0xcd, +0x11, 0xe5, 0x30, 0x66, 0xe4, 0x0a, 0xa6, 0xe4, 0x22, 0x41, 0xb2, 0x1a, +0x86, 0x9a, 0xa8, 0x27, 0x16, 0xf1, 0xbb, 0x56, 0x1f, 0x39, 0x2a, 0x44, +0x86, 0xe6, 0x4a, 0xd8, 0xa6, 0xa0, 0x40, 0x5c, 0xda, 0x50, 0x11, 0x66, +0x82, 0xd6, 0x88, 0x5d, 0xa9, 0xf1, 0xc1, 0xbc, 0xfb, 0x1f, 0x4e, 0x88, +0x49, 0xcf, 0x33, 0xe0, 0x45, 0xe0, 0xb9, 0x36, 0x28, 0x10, 0x57, 0x73, +0x76, 0x13, 0xaf, 0x1e, 0xba, 0xdf, 0xc5, 0x9d, 0x14, 0x87, 0x77, 0x61, +0x8a, 0x79, 0xc9, 0x7d, 0xc6, 0x38, 0x34, 0x54, 0xb0, 0x39, 0xb1, 0x02, +0xe1, 0xf2, 0xc7, 0xf5, 0xef, 0x17, 0xc7, 0x2d, 0x79, 0x33, 0x68, 0x82, +0x7b, 0xc2, 0xf0, 0xd2, 0x92, 0x72, 0x81, 0x60, 0x67, 0xd6, 0x05, 0x53, +0x24, 0x81, 0xc8, 0xbd, 0xe0, 0x5e, 0xcd, 0xd9, 0x91, 0xa8, 0x86, 0x31, +0xc3, 0x4b, 0x27, 0x9a, 0xdc, 0x2d, 0x7a, 0xed, 0xa5, 0x23, 0x17, 0x31, +0x1a, 0xa7, 0xf3, 0x5f, 0x25, 0x05, 0x22, 0x42, 0x3b, 0x1a, 0x3c, 0x08, +0x18, 0x2f, 0xbc, 0xe4, 0x27, 0xfb, 0x74, 0xe6, 0x73, 0xc4, 0x10, 0x08, +0xff, 0xfd, 0x61, 0x80, 0x31, 0xa8, 0x02, 0x91, 0xa0, 0xcd, 0xc6, 0x4b, +0xaf, 0xdb, 0x51, 0x9a, 0x0d, 0xec, 0xde, 0xf2, 0x88, 0x83, 0x7e, 0x16, +0xed, 0xad, 0xe4, 0xa8, 0x33, 0xc7, 0x8b, 0x3d, 0x2e, 0x10, 0x53, 0xc6, +0xcf, 0x7b, 0xb9, 0x24, 0x1c, 0x4f, 0x17, 0x46, 0x0c, 0x2f, 0x5d, 0x5d, +0x98, 0xa3, 0xe4, 0x43, 0x98, 0x7c, 0xcd, 0x71, 0xea, 0xbd, 0x07, 0x97, +0x52, 0x65, 0xdb, 0x91, 0xc7, 0xf0, 0xba, 0x19, 0xa3, 0xd0, 0x02, 0x31, +0x0f, 0xc7, 0x2d, 0xb5, 0x7c, 0x26, 0xc2, 0x4c, 0x63, 0x84, 0x99, 0xf4, +0xb2, 0xa0, 0xdc, 0x02, 0x11, 0xa3, 0x1d, 0x3e, 0x02, 0x01, 0xc3, 0x84, +0x97, 0x22, 0x97, 0x97, 0x5e, 0xfe, 0x5c, 0x1c, 0x44, 0x1a, 0xc7, 0x9b, +0x35, 0x77, 0x9f, 0x67, 0x0b, 0x2b, 0x22, 0x10, 0xc0, 0x84, 0x2c, 0x5b, +0x5a, 0x3a, 0x39, 0xca, 0x5d, 0x87, 0x0b, 0x33, 0x5d, 0x14, 0x88, 0xa6, +0x3c, 0x08, 0x47, 0x9e, 0x0c, 0x7a, 0x73, 0xe9, 0x73, 0xee, 0x84, 0xae, +0x7e, 0x3e, 0x76, 0x68, 0xed, 0x71, 0x66, 0xe1, 0xd5, 0x9b, 0x04, 0x1b, +0x14, 0x08, 0x3c, 0x5c, 0xe8, 0x5f, 0x20, 0x12, 0xee, 0xd4, 0x2f, 0x79, +0x11, 0x84, 0x99, 0xc6, 0xf0, 0x6a, 0x25, 0xff, 0xd0, 0x9a, 0x40, 0xb0, +0x79, 0x81, 0x2e, 0x77, 0x6b, 0x2e, 0x6f, 0x6b, 0x8b, 0x18, 0x39, 0x12, +0x7a, 0x33, 0x75, 0x1e, 0x66, 0x92, 0x86, 0x8f, 0xb9, 0x05, 0x22, 0xc2, +0xe6, 0x6a, 0xe2, 0x55, 0x43, 0xcd, 0xc4, 0x4a, 0x50, 0x2f, 0x95, 0x4f, +0x44, 0xe2, 0xbc, 0x9d, 0x8f, 0x4b, 0x11, 0x08, 0xa9, 0x64, 0xca, 0xbc, +0x2b, 0x5f, 0x1c, 0x07, 0xe4, 0x00, 0x57, 0xbe, 0xf8, 0x4e, 0xe8, 0x74, +0x98, 0x49, 0x6a, 0xe4, 0x71, 0xe5, 0xfb, 0x1f, 0x9b, 0xf2, 0x9e, 0x33, +0x5f, 0x18, 0x74, 0xca, 0xd3, 0x71, 0xaf, 0x1b, 0x57, 0x02, 0x54, 0x43, +0x2b, 0x27, 0x41, 0x27, 0x47, 0x77, 0xd7, 0xd1, 0x38, 0xf4, 0xce, 0xf5, +0xb0, 0x9c, 0x3f, 0x81, 0x5f, 0xfb, 0x1c, 0x22, 0xb4, 0x04, 0xf5, 0x13, +0x29, 0x41, 0x3d, 0xd7, 0xb6, 0x58, 0xb8, 0x20, 0x49, 0xcd, 0x1d, 0x11, +0x6d, 0x72, 0x24, 0x3f, 0xa6, 0x87, 0xe5, 0xfc, 0xe5, 0x53, 0x39, 0x77, +0xe7, 0x47, 0x4f, 0x7f, 0x13, 0xee, 0x84, 0xa1, 0x04, 0x22, 0xc7, 0x6e, +0xe8, 0x92, 0x40, 0xf8, 0x5d, 0x25, 0x02, 0xd1, 0xf9, 0xf8, 0x94, 0x52, +0x57, 0x7f, 0x9a, 0x3a, 0xf7, 0x0e, 0x7d, 0x57, 0x38, 0x8c, 0x50, 0x27, +0x74, 0xbb, 0x43, 0x73, 0x65, 0x63, 0xa9, 0xa7, 0x73, 0x25, 0x22, 0x10, +0x7e, 0x57, 0xc9, 0xce, 0xad, 0x3d, 0x0e, 0x6d, 0x0c, 0xb4, 0x92, 0xa9, +0xe2, 0x5b, 0xe5, 0xd8, 0xa4, 0x40, 0x33, 0xc4, 0xa8, 0x60, 0xca, 0x55, +0x89, 0x71, 0xe9, 0xde, 0xdf, 0xdc, 0x3d, 0x7a, 0x20, 0x1e, 0x47, 0xc6, +0xa8, 0xfc, 0xdd, 0x02, 0x89, 0xea, 0xf7, 0xf9, 0xf4, 0x62, 0x9c, 0xb2, +0x41, 0x81, 0xb6, 0x04, 0xc2, 0x35, 0xd2, 0x26, 0xe0, 0xaa, 0xa7, 0x23, +0x02, 0x81, 0x7b, 0xdf, 0x26, 0x47, 0xc3, 0x4c, 0xf2, 0xae, 0xfd, 0x86, +0xa0, 0xd4, 0x6e, 0x5d, 0xbc, 0x9e, 0x59, 0x3e, 0xb7, 0x08, 0x96, 0x1f, +0xbb, 0x13, 0x6f, 0x12, 0x46, 0xf4, 0x20, 0xb2, 0x0c, 0x7c, 0x99, 0x64, +0x57, 0x3e, 0x2b, 0x02, 0xd1, 0x34, 0x53, 0xc3, 0xef, 0x9b, 0x52, 0x56, +0x18, 0x53, 0x20, 0x32, 0x56, 0x06, 0xdd, 0x10, 0x88, 0xb1, 0x39, 0xf3, +0xee, 0x4f, 0x5c, 0x77, 0x0b, 0x00, 0xc1, 0xee, 0xa6, 0x85, 0x1e, 0x47, +0x97, 0x3d, 0x1d, 0x04, 0xa2, 0x6d, 0x2e, 0x56, 0xdb, 0xcd, 0xec, 0xe4, +0x01, 0x0a, 0x2c, 0xbc, 0x2e, 0x4f, 0xe2, 0x17, 0x81, 0x80, 0x29, 0xc2, +0x66, 0x66, 0x41, 0x28, 0x00, 0x0e, 0x70, 0x35, 0xf9, 0x9b, 0xc9, 0x8b, +0xb8, 0x1c, 0x0a, 0x13, 0x81, 0xe0, 0x34, 0xf5, 0xd8, 0x9b, 0x19, 0x73, +0x60, 0x52, 0x84, 0x82, 0x72, 0x53, 0x80, 0xd4, 0x02, 0xe1, 0xf2, 0x9c, +0x85, 0xb8, 0xcb, 0x41, 0xb7, 0xb3, 0x0b, 0x84, 0x39, 0x07, 0x41, 0x99, +0xeb, 0xe0, 0x63, 0xd5, 0x91, 0x9f, 0x00, 0xc8, 0x3f, 0xe9, 0x12, 0x87, +0x6f, 0x66, 0x59, 0xe0, 0xfd, 0x69, 0xe8, 0xdd, 0x7d, 0x79, 0x1c, 0x77, +0x42, 0xf4, 0x46, 0xcc, 0x7b, 0xd3, 0xed, 0xb8, 0xc5, 0x9b, 0x00, 0x48, +0xbd, 0x2b, 0x4b, 0xb8, 0x43, 0x5f, 0x24, 0x44, 0x74, 0x44, 0x20, 0xbc, +0xc7, 0x40, 0x6b, 0xe5, 0xbe, 0xb8, 0xbb, 0xc8, 0x02, 0x21, 0xad, 0x39, +0xfc, 0x58, 0x41, 0x24, 0x00, 0x12, 0x0b, 0x44, 0xaa, 0x73, 0x11, 0xb3, +0x08, 0xc4, 0xca, 0xa2, 0xbf, 0x29, 0x0e, 0xfe, 0xa0, 0x14, 0x2d, 0x0e, +0x18, 0xaf, 0xab, 0x1e, 0xa5, 0xfd, 0xfd, 0xdc, 0xf7, 0x58, 0x03, 0x0c, +0x2b, 0x10, 0x89, 0xf2, 0x11, 0x77, 0x33, 0x91, 0x3f, 0x4d, 0x70, 0x2b, +0x1c, 0x41, 0xcb, 0x67, 0x5a, 0x1c, 0xf4, 0xc7, 0x74, 0x76, 0x6c, 0xca, +0x38, 0x59, 0xcb, 0x63, 0xc9, 0xb8, 0xa2, 0xc2, 0x0d, 0x20, 0x8f, 0x07, +0x91, 0x64, 0xb2, 0xc9, 0xe7, 0xd4, 0x70, 0x80, 0x76, 0x67, 0xd5, 0x4b, +0xea, 0xed, 0xa4, 0x37, 0x17, 0xd7, 0xd3, 0x3d, 0xb3, 0x53, 0xce, 0x9e, +0x89, 0xd0, 0x6a, 0xb6, 0x50, 0x24, 0x8c, 0x77, 0x0a, 0x00, 0xa9, 0x05, +0xc2, 0x4f, 0xc0, 0xe8, 0x3b, 0x47, 0x11, 0x05, 0xbd, 0x98, 0x5e, 0x4c, +0xc4, 0xc0, 0x7a, 0x0a, 0xda, 0xc9, 0x53, 0x7f, 0x0f, 0x71, 0xc0, 0x8b, +0x70, 0x1b, 0x21, 0x25, 0x2b, 0x12, 0x15, 0xf4, 0x6e, 0x02, 0xe8, 0x6b, +0x37, 0xe6, 0xca, 0x34, 0xf1, 0x5b, 0x74, 0x92, 0x87, 0xbb, 0x40, 0x0d, +0x35, 0xc9, 0xaf, 0x5e, 0xf4, 0x08, 0x2b, 0xb1, 0xb1, 0xd9, 0x4c, 0x4c, +0xdb, 0x8d, 0x85, 0x11, 0x88, 0x89, 0x27, 0x0b, 0x90, 0x41, 0x20, 0x12, +0xee, 0xde, 0xef, 0xda, 0x25, 0xd3, 0x7a, 0x2c, 0x7e, 0xc1, 0x58, 0xfc, +0x24, 0xa7, 0x9c, 0x15, 0x2f, 0xe2, 0xe9, 0xa9, 0x7a, 0x9b, 0xb7, 0x42, +0x20, 0x00, 0xb6, 0x39, 0x7d, 0x11, 0x8f, 0x2b, 0x7b, 0x73, 0xd6, 0xcd, +0x4f, 0xe8, 0x89, 0xd0, 0xc0, 0xb0, 0x9c, 0x3a, 0x17, 0x61, 0x4a, 0x5b, +0x4b, 0xdf, 0x42, 0x07, 0xd0, 0xef, 0x4e, 0xcc, 0x71, 0xb5, 0x22, 0x14, +0xe6, 0x4c, 0xa8, 0xc9, 0x0a, 0x84, 0x84, 0x9a, 0x0a, 0x5e, 0x30, 0x04, +0x80, 0x40, 0x00, 0xa4, 0xf4, 0x24, 0x8f, 0x8a, 0x44, 0x28, 0x10, 0x3e, +0x1f, 0x81, 0xf7, 0x00, 0xb0, 0x42, 0xf4, 0xd3, 0xa9, 0xee, 0xef, 0x79, +0x08, 0x80, 0x2c, 0x22, 0xe1, 0x76, 0x86, 0x9b, 0x82, 0x73, 0x32, 0xb3, +0x37, 0x42, 0x94, 0x00, 0x5b, 0xc4, 0x4e, 0x54, 0xd3, 0x08, 0x0d, 0x0a, +0x7a, 0xc3, 0xcb, 0x96, 0x47, 0xa1, 0xe1, 0x24, 0x4e, 0x4e, 0x03, 0x9c, +0xdb, 0x81, 0x7d, 0x32, 0x11, 0x8f, 0xbd, 0xe6, 0xff, 0x0d, 0x97, 0xb3, +0x40, 0x2d, 0x62, 0x31, 0xeb, 0x18, 0x16, 0xd1, 0x90, 0xb0, 0x92, 0x98, +0x1f, 0xab, 0x8c, 0x51, 0x00, 0x00, 0xf8, 0xb0, 0x11, 0x42, 0x18, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x03, 0xee, +0x3c, 0x02, 0x00, 0x00, 0x08, 0x99, 0xbd, 0x01, 0x00, 0x00, 0xbc, 0xb3, +0xfc, 0xb1, 0xb7, 0x3f, 0x36, 0xf1, 0x28, 0x00, 0x00, 0xe0, 0x83, 0x38, +0x7c, 0xf9, 0xf2, 0xe5, 0xbf, 0x3c, 0x0a, 0x00, 0x00, 0x10, 0x66, 0x2f, +0x0a, 0x6f, 0xde, 0x16, 0x1e, 0x09, 0x00, 0xc0, 0x78, 0xdc, 0xbd, 0x49, +0x8e, 0x61, 0x09, 0x84, 0xe1, 0xed, 0xdb, 0xb7, 0x6f, 0xff, 0x73, 0x24, +0xa8, 0x01, 0x00, 0xba, 0xe7, 0xe6, 0xfe, 0xcd, 0x25, 0xcc, 0x5f, 0xbf, +0x7e, 0xfd, 0x8f, 0x88, 0x81, 0x17, 0x80, 0xb7, 0x27, 0x46, 0x72, 0x1a, +0x00, 0x00, 0x31, 0x58, 0xb5, 0x1b, 0x8f, 0x12, 0x00, 0xa0, 0x0f, 0x44, +0x14, 0x96, 0x93, 0x62, 0xf0, 0xc1, 0x44, 0x58, 0x78, 0x9c, 0x00, 0x00, +0xed, 0x7b, 0x0b, 0x61, 0x62, 0xf9, 0x92, 0x79, 0x81, 0xc1, 0x7b, 0x00, +0x00, 0x68, 0x94, 0x7b, 0x2c, 0x6f, 0x61, 0xc5, 0x26, 0x1e, 0x2f, 0x00, +0x40, 0x7b, 0x4c, 0xe2, 0x2d, 0x7c, 0xff, 0xfe, 0xfd, 0x1f, 0xb1, 0xd8, +0xe2, 0x40, 0x68, 0x09, 0x00, 0xa0, 0x41, 0x8f, 0x41, 0x84, 0xe1, 0xc7, +0x8f, 0x1f, 0xff, 0xfc, 0xfc, 0xf9, 0xf3, 0x2d, 0x85, 0x38, 0x10, 0x5a, +0x02, 0x00, 0x68, 0x8f, 0x59, 0x16, 0xef, 0x5f, 0xbf, 0x7e, 0xbd, 0x89, +0xa5, 0x10, 0x07, 0x47, 0x59, 0x2b, 0x00, 0x40, 0x53, 0x4c, 0xea, 0x35, +0x88, 0x30, 0xa4, 0xf2, 0x1c, 0x1c, 0xa1, 0x25, 0x00, 0x80, 0xb6, 0xc4, +0x41, 0xbd, 0x86, 0xdf, 0xbf, 0x7f, 0xbf, 0x2d, 0xcb, 0x92, 0xc2, 0x63, +0x78, 0x98, 0xaf, 0x80, 0x22, 0xb4, 0x04, 0x00, 0xd0, 0x8a, 0x38, 0x88, +0xc7, 0x90, 0x5a, 0x1c, 0x68, 0xa7, 0x01, 0x00, 0xd0, 0xa8, 0xe7, 0x20, +0x22, 0x91, 0xa8, 0x94, 0xf5, 0x11, 0xae, 0xf2, 0xe2, 0x43, 0xee, 0x01, +0x00, 0xa0, 0x62, 0x24, 0xc4, 0xb3, 0xc8, 0xa2, 0xad, 0x9e, 0x43, 0x6a, +0x71, 0x08, 0x3c, 0x94, 0x49, 0x05, 0xca, 0xd8, 0xec, 0x7f, 0x25, 0xfc, +0x04, 0x00, 0x50, 0x4a, 0x1c, 0x34, 0x19, 0x2d, 0x0b, 0x76, 0xea, 0xb0, +0x92, 0x33, 0xe1, 0x25, 0x2b, 0x12, 0x5b, 0xa7, 0xb1, 0xbd, 0x48, 0x2d, +0xde, 0x44, 0x34, 0x8e, 0x86, 0xa4, 0x08, 0x61, 0x01, 0x00, 0x9c, 0xe0, +0x71, 0xbe, 0x41, 0x16, 0xe8, 0x9c, 0xe2, 0x60, 0x4d, 0x85, 0x49, 0xc4, +0xe2, 0xc0, 0xbf, 0x5b, 0x8c, 0x87, 0xf1, 0xcc, 0xcb, 0x98, 0x1d, 0x77, +0x4a, 0x00, 0x00, 0xec, 0xde, 0x4d, 0x3f, 0x16, 0x4d, 0x29, 0x2d, 0x95, +0x50, 0x8f, 0xe6, 0x1b, 0xe4, 0x57, 0x59, 0xac, 0x73, 0x8a, 0x83, 0x9a, +0x0a, 0xd4, 0xd9, 0xef, 0x6f, 0xbd, 0x0c, 0xf9, 0xb9, 0xc4, 0xe4, 0xf7, +0xbc, 0x57, 0x32, 0xf1, 0xda, 0x01, 0x00, 0xfe, 0x72, 0x73, 0x7f, 0x2f, +0xe4, 0xd1, 0x5d, 0xf6, 0x6c, 0x4f, 0x43, 0x5b, 0x61, 0x90, 0x05, 0x3a, +0x55, 0xbe, 0x61, 0xaf, 0xe9, 0x67, 0x72, 0x94, 0xcf, 0x02, 0x00, 0x44, +0xf1, 0x06, 0x74, 0xf1, 0x7f, 0xec, 0x9e, 0x65, 0x51, 0xb4, 0xbd, 0x92, +0x44, 0x0c, 0x64, 0xf1, 0xd7, 0xc5, 0x57, 0x0f, 0xbc, 0x89, 0xc9, 0x9f, +0x25, 0x3c, 0x15, 0x7d, 0xca, 0x0b, 0xb8, 0xe2, 0x45, 0x38, 0xca, 0x67, +0x01, 0x60, 0x70, 0xaf, 0xe0, 0xe1, 0x09, 0x68, 0x78, 0x48, 0x17, 0x79, +0xeb, 0x15, 0xac, 0x99, 0x0a, 0x42, 0x2d, 0x62, 0xf0, 0x2c, 0xd4, 0x14, +0xc9, 0x8b, 0x20, 0xac, 0x04, 0x00, 0xdd, 0x8b, 0xc1, 0x07, 0x41, 0x58, +0x13, 0x03, 0xf9, 0x6f, 0x59, 0x58, 0xe5, 0xf7, 0x55, 0x30, 0x64, 0x07, +0x5d, 0x3a, 0x64, 0x74, 0x76, 0xe7, 0x1f, 0xa1, 0xdf, 0x13, 0x49, 0x69, +0x00, 0xe8, 0x52, 0x14, 0x66, 0x4d, 0xb0, 0xba, 0xe0, 0xdc, 0x80, 0xb5, +0x16, 0x17, 0x7f, 0x77, 0xa0, 0xaa, 0xe9, 0x82, 0xb7, 0xc3, 0xa1, 0x3b, +0x00, 0xe8, 0x4b, 0x14, 0x6c, 0xee, 0xa0, 0xb6, 0xdc, 0x40, 0xa9, 0x50, +0xd3, 0x11, 0x11, 0xf4, 0x7f, 0x17, 0x71, 0x00, 0x80, 0xbe, 0x84, 0x41, +0x17, 0xb8, 0x56, 0xc3, 0x42, 0x2e, 0xd1, 0x49, 0xeb, 0xbd, 0x22, 0x49, +0x42, 0x1a, 0x00, 0x7a, 0x21, 0xe5, 0x55, 0x9d, 0xdd, 0x85, 0x9a, 0xdc, +0xbe, 0x52, 0x56, 0xc4, 0x01, 0x00, 0x9a, 0xf5, 0x14, 0x1e, 0xa2, 0xb0, +0xd5, 0x4a, 0x02, 0xdb, 0xf6, 0x22, 0x76, 0x84, 0x94, 0x38, 0xe7, 0x00, +0x43, 0x2e, 0x2a, 0xb6, 0x8a, 0xe5, 0x8c, 0xdd, 0xcd, 0xd7, 0xb9, 0x31, +0x91, 0xb2, 0x88, 0xc0, 0xe4, 0xcc, 0x29, 0xe5, 0xb5, 0x64, 0x33, 0x76, +0xbc, 0xaa, 0x49, 0x9f, 0xa5, 0xe6, 0x69, 0xdc, 0xbf, 0x55, 0x4a, 0x78, +0x0d, 0xd0, 0xed, 0x42, 0xf2, 0x61, 0x11, 0xd1, 0x81, 0xaf, 0x16, 0x2b, +0x16, 0x6d, 0xe3, 0xda, 0xda, 0x76, 0xc0, 0x9a, 0x7e, 0x7f, 0xf7, 0xb7, +0x11, 0xda, 0x5a, 0x7f, 0x1b, 0x84, 0xe5, 0xc5, 0xbb, 0x93, 0x67, 0x6b, +0x0f, 0xa5, 0x1d, 0x89, 0x9f, 0x63, 0xbb, 0xf2, 0x0b, 0x00, 0x7d, 0x2f, +0x26, 0xba, 0x90, 0xb4, 0x36, 0x39, 0xad, 0xb0, 0xe8, 0xa2, 0xb8, 0x21, +0x2c, 0x56, 0x54, 0xdc, 0x8a, 0xf7, 0x72, 0x6b, 0xe4, 0xbd, 0x4d, 0x2e, +0xe8, 0xe9, 0x63, 0xab, 0x8b, 0xf4, 0x54, 0xf2, 0xda, 0xc9, 0x64, 0x15, +0x07, 0x16, 0xf6, 0xe3, 0xb9, 0x86, 0xad, 0xb9, 0xe1, 0x9f, 0x27, 0xde, +0x02, 0x34, 0x2d, 0x06, 0x1f, 0x42, 0x0b, 0x23, 0x87, 0x15, 0x54, 0x50, +0x54, 0x5c, 0x6c, 0xed, 0xbe, 0x5d, 0x70, 0x03, 0x71, 0x51, 0xcf, 0x65, +0xcd, 0x5e, 0x85, 0xd2, 0x6e, 0x3b, 0xec, 0xee, 0x3e, 0xdf, 0x33, 0xa0, +0xf6, 0xde, 0xa2, 0x42, 0x45, 0x40, 0x85, 0xc0, 0xb6, 0xa8, 0xd0, 0x4e, +0xa7, 0xd6, 0x10, 0x85, 0xf3, 0xb9, 0x05, 0x9d, 0x23, 0xda, 0x2c, 0x70, +0x6b, 0xce, 0xf8, 0xdf, 0x9f, 0x58, 0x66, 0xa0, 0x15, 0xde, 0x3d, 0x83, +0x16, 0xbd, 0x82, 0xdc, 0x62, 0xa1, 0x0b, 0xae, 0xb5, 0xb5, 0xc3, 0x5e, +0xe1, 0x22, 0x1b, 0x8a, 0x8b, 0x5b, 0x39, 0x2c, 0x66, 0x4f, 0x16, 0x3f, +0xfb, 0x33, 0x6b, 0xba, 0xf0, 0x87, 0x02, 0xb0, 0x25, 0x02, 0x5b, 0xa2, +0xc0, 0x7b, 0xbf, 0x76, 0x49, 0x90, 0xbe, 0x53, 0x79, 0x27, 0x3b, 0x5a, +0x6b, 0x20, 0x10, 0x50, 0x7f, 0xd8, 0x81, 0x2a, 0x94, 0x3a, 0x42, 0x5e, +0xb6, 0x95, 0xc4, 0x2b, 0x81, 0x08, 0x05, 0xc1, 0x0a, 0x43, 0xd8, 0xbb, +0x68, 0x4b, 0x14, 0xb4, 0xdb, 0x29, 0x9e, 0xc2, 0xb5, 0x30, 0x92, 0x7d, +0xc6, 0xfa, 0x2c, 0x55, 0x30, 0x10, 0x08, 0x68, 0x52, 0x14, 0x9e, 0xb9, +0xbe, 0xec, 0x22, 0xfb, 0x3c, 0x9c, 0x15, 0x7a, 0x26, 0x3c, 0x9b, 0xeb, +0xf7, 0x4e, 0xab, 0x10, 0xd8, 0x8b, 0x81, 0xe4, 0xcf, 0xf4, 0xf7, 0x10, +0x08, 0x68, 0x21, 0x74, 0x34, 0x51, 0x9a, 0x88, 0x61, 0xf1, 0xc4, 0xc1, +0x5e, 0x44, 0xa4, 0x9e, 0x5a, 0xe8, 0x3d, 0x10, 0x62, 0x02, 0x42, 0x47, +0x18, 0x36, 0x98, 0xd9, 0x90, 0x92, 0x9e, 0x8a, 0xd6, 0xcd, 0x97, 0x76, +0x6d, 0xdd, 0x79, 0xd5, 0x28, 0x02, 0x01, 0xf9, 0x44, 0x01, 0x2f, 0x01, +0xc3, 0xf2, 0xdc, 0x33, 0xbd, 0x75, 0xcf, 0xb5, 0xfd, 0xf3, 0x1d, 0x02, +0x41, 0x99, 0x2b, 0x24, 0x15, 0x85, 0x19, 0x51, 0xc0, 0xb0, 0x72, 0x02, +0x21, 0x66, 0xe7, 0x9f, 0xde, 0x41, 0xfd, 0x4a, 0x20, 0x68, 0xc4, 0x07, +0xc9, 0x44, 0x81, 0x32, 0x54, 0x0c, 0x2b, 0xdb, 0xb2, 0x7b, 0xcb, 0x8b, +0xb0, 0x49, 0xeb, 0xd0, 0xbb, 0xc0, 0x83, 0x80, 0x54, 0x64, 0x15, 0x05, +0x2a, 0x99, 0x30, 0x6c, 0x5f, 0x15, 0x93, 0xf5, 0x16, 0xac, 0x38, 0xd8, +0x92, 0x57, 0x72, 0x10, 0x90, 0x54, 0x18, 0x72, 0x0d, 0xfa, 0xb0, 0x16, +0x9f, 0x85, 0x00, 0xc3, 0x5e, 0x0b, 0x85, 0xbd, 0x2a, 0xf5, 0x40, 0xfe, +0x01, 0x81, 0x80, 0xd3, 0x14, 0xab, 0x40, 0x42, 0x18, 0x30, 0x2c, 0x4e, +0x23, 0xc9, 0x1d, 0x7f, 0x9f, 0x10, 0x13, 0xd4, 0xeb, 0x31, 0x10, 0x4e, +0xc2, 0xb0, 0xa2, 0xc6, 0x55, 0xa2, 0x50, 0xaf, 0x30, 0x70, 0xa2, 0x16, +0xc3, 0x8a, 0xb7, 0xfc, 0xa6, 0xed, 0x3c, 0xac, 0x72, 0x2b, 0x15, 0x4a, +0xb2, 0xcd, 0xe5, 0x98, 0xa8, 0x18, 0x56, 0xd4, 0x16, 0x96, 0x42, 0xb0, +0x14, 0xbd, 0xbb, 0x57, 0x9b, 0xba, 0x11, 0x56, 0xc2, 0xb0, 0x6a, 0xbc, +0x08, 0x92, 0xd5, 0xf0, 0xbc, 0x49, 0x5e, 0x6a, 0xd3, 0xfe, 0xf4, 0x3b, +0xab, 0x2b, 0x30, 0x0c, 0xcb, 0x64, 0x3e, 0x8a, 0x40, 0xc2, 0x7a, 0x54, +0x61, 0xf0, 0xb7, 0x94, 0x15, 0x3f, 0xd8, 0x83, 0x38, 0x60, 0x58, 0x9d, +0xe6, 0xd7, 0x08, 0x40, 0x18, 0xf2, 0xba, 0xaf, 0x7a, 0x78, 0x07, 0x71, +0xc0, 0x30, 0xf2, 0x11, 0x80, 0x30, 0x7c, 0x08, 0x29, 0xd9, 0x8e, 0x93, +0x18, 0x86, 0x55, 0x6f, 0x84, 0x9a, 0x3a, 0x65, 0xae, 0xa5, 0xbd, 0xb6, +0xbd, 0xb0, 0x04, 0x71, 0xc0, 0x30, 0x04, 0x02, 0x0a, 0x7a, 0x0c, 0x35, +0x08, 0x83, 0xff, 0x0c, 0x8b, 0x0d, 0x2b, 0xed, 0x68, 0x16, 0x86, 0x61, +0x58, 0x5d, 0xc9, 0x6a, 0x20, 0x94, 0x14, 0x2f, 0xc7, 0xe0, 0x3f, 0x83, +0xee, 0x3a, 0x26, 0xf5, 0x1e, 0xc8, 0x39, 0x60, 0x18, 0x89, 0x6a, 0x18, +0xd0, 0x63, 0xf0, 0xdf, 0x5f, 0x8e, 0xe9, 0x87, 0xa7, 0x30, 0x17, 0xed, +0x57, 0x4f, 0x68, 0x09, 0x6b, 0xd5, 0x06, 0x3e, 0xa3, 0x43, 0x92, 0x9a, +0x1c, 0xc3, 0xa5, 0x49, 0xb3, 0x3c, 0x8b, 0x51, 0xca, 0x0e, 0x44, 0x4b, +0x5a, 0x39, 0x08, 0x87, 0xb5, 0x6a, 0xb2, 0xb9, 0x19, 0x74, 0xfc, 0x4e, +0x2c, 0xb3, 0x08, 0x43, 0x74, 0x61, 0x50, 0xe4, 0x73, 0x8a, 0x40, 0xec, +0xb8, 0x2c, 0x1d, 0xc3, 0xaa, 0x35, 0x19, 0xc3, 0x03, 0xb6, 0x81, 0xc1, +0x7b, 0x68, 0x88, 0x5b, 0x45, 0xc2, 0xb0, 0xbb, 0x99, 0x97, 0x7c, 0x5e, +0xbd, 0xb8, 0x84, 0x85, 0x06, 0x6b, 0x59, 0x20, 0x46, 0xf2, 0x20, 0xfc, +0x3a, 0x43, 0xd3, 0xbe, 0x16, 0xbc, 0x85, 0xd2, 0x77, 0x3c, 0xfb, 0xef, +0x3d, 0x9f, 0x18, 0x30, 0x37, 0xad, 0x60, 0x42, 0x20, 0xb0, 0x96, 0xf3, +0x0f, 0x32, 0x7e, 0x07, 0x0b, 0x31, 0x11, 0x5a, 0xaa, 0x98, 0x47, 0xf3, +0xbc, 0x8a, 0x13, 0xcf, 0x47, 0xbc, 0x9e, 0x37, 0x04, 0x02, 0x6b, 0x3d, +0xff, 0x30, 0xca, 0xf8, 0x35, 0x9b, 0x41, 0xa8, 0x8c, 0xa9, 0x06, 0x51, +0x88, 0x24, 0x0c, 0x78, 0x10, 0x58, 0x57, 0xe1, 0xa5, 0x81, 0xc6, 0x2f, +0x9e, 0x03, 0x9e, 0x42, 0x72, 0x61, 0x40, 0x20, 0xb0, 0x6e, 0x4c, 0x0a, +0x2c, 0x7a, 0x3f, 0xe0, 0x49, 0x8b, 0xef, 0xba, 0x44, 0xa1, 0x78, 0x5e, +0x21, 0x93, 0x5b, 0x89, 0x40, 0x60, 0x4d, 0x9b, 0x1e, 0xf2, 0xcc, 0x59, +0xc1, 0x64, 0x0e, 0x9b, 0x66, 0xd9, 0x3c, 0x06, 0x07, 0x5b, 0xa1, 0xa4, +0x28, 0xd4, 0x36, 0x01, 0x12, 0x0f, 0x8e, 0xae, 0x04, 0x82, 0xdb, 0xee, +0xc6, 0xb3, 0x9c, 0x63, 0x57, 0x5b, 0xd3, 0xac, 0x78, 0xf0, 0x29, 0xd7, +0x0f, 0x4a, 0x59, 0x0b, 0x70, 0xf3, 0xee, 0x5a, 0x35, 0xcd, 0xf2, 0x36, +0x84, 0x21, 0xb9, 0x4b, 0xd9, 0xd3, 0x39, 0x08, 0x11, 0x08, 0x4e, 0x83, +0x8f, 0x55, 0xbd, 0x24, 0xe3, 0x36, 0xf5, 0xc6, 0xc0, 0x94, 0x8f, 0xef, +0x0e, 0x4b, 0x5f, 0x89, 0x40, 0x18, 0x21, 0xc2, 0x6b, 0xc8, 0x24, 0x06, +0x77, 0x1f, 0xa2, 0x59, 0x6a, 0x0a, 0x1d, 0xd5, 0x50, 0xa5, 0xd0, 0xd3, +0x49, 0x6a, 0x59, 0x28, 0x08, 0x95, 0x91, 0x9c, 0x8e, 0x31, 0x8e, 0x74, +0x2e, 0x5c, 0xf4, 0xe0, 0x75, 0x23, 0xfa, 0x58, 0x77, 0x5e, 0x99, 0x17, +0x05, 0xf2, 0x0c, 0x89, 0x04, 0xe0, 0xae, 0x5e, 0x81, 0xbe, 0x10, 0x51, +0xe2, 0x56, 0x16, 0x3d, 0x13, 0xd7, 0xcc, 0x7a, 0xf8, 0x45, 0xbe, 0x67, +0x4f, 0xbd, 0x98, 0x72, 0xec, 0x28, 0xb1, 0x7e, 0x73, 0x0f, 0x32, 0x07, +0x4c, 0xdb, 0x0e, 0xc2, 0x3b, 0x0d, 0x2d, 0xfe, 0x2a, 0x00, 0x53, 0x8b, +0x02, 0xb0, 0x43, 0x18, 0x4a, 0xb9, 0x93, 0xef, 0xcd, 0xfa, 0x7a, 0xa8, +0x04, 0x91, 0x1d, 0x25, 0x61, 0x26, 0x72, 0x0f, 0x67, 0xbd, 0x4f, 0xf9, +0x95, 0xa4, 0x70, 0xbd, 0x89, 0xe2, 0xf7, 0x85, 0x5f, 0x17, 0xff, 0x9e, +0x4f, 0x47, 0x56, 0x72, 0xf1, 0xf8, 0xdc, 0x53, 0xbb, 0xef, 0x91, 0x0e, +0x4d, 0x8d, 0x6a, 0xba, 0xa1, 0x89, 0xe1, 0x3d, 0xc8, 0xfa, 0xa2, 0xa1, +0x2a, 0x3f, 0x1f, 0x09, 0xf1, 0x54, 0xe8, 0x25, 0x2c, 0x23, 0x0d, 0x70, +0x73, 0x9e, 0xa1, 0x06, 0x26, 0x99, 0x24, 0x3d, 0x09, 0x04, 0x8d, 0x07, +0x39, 0xf7, 0x70, 0x64, 0x33, 0xe1, 0xbf, 0x16, 0xe1, 0xa4, 0x1a, 0xa9, +0xb5, 0x8a, 0xa8, 0x87, 0x04, 0xf4, 0x5e, 0xcf, 0x4d, 0xab, 0x41, 0x7a, +0x48, 0x54, 0xeb, 0xee, 0x92, 0x85, 0xb4, 0xdf, 0xc4, 0xf4, 0x55, 0xef, +0x41, 0xef, 0x5e, 0x17, 0x2b, 0x91, 0xf7, 0x83, 0x03, 0xf1, 0xef, 0xc1, +0x84, 0xa1, 0xc6, 0x81, 0x78, 0xb3, 0x02, 0xd1, 0x7a, 0x82, 0xb7, 0xc4, +0xc1, 0x29, 0x2c, 0xaf, 0xf8, 0x9f, 0xf5, 0x1e, 0x34, 0xcf, 0x60, 0xbe, +0x06, 0x5e, 0x43, 0xcd, 0xa1, 0xa5, 0xde, 0xbb, 0x2f, 0x9a, 0xb3, 0x0c, +0xb7, 0xda, 0xdf, 0x83, 0x0a, 0x44, 0xeb, 0x09, 0x5e, 0x15, 0x08, 0x12, +0xd5, 0x7d, 0x56, 0x2d, 0x9d, 0x69, 0xeb, 0x6d, 0x85, 0x41, 0xc6, 0x39, +0xb9, 0x86, 0x36, 0x98, 0x3a, 0x17, 0x86, 0x56, 0xaa, 0x20, 0x66, 0x8d, +0xeb, 0xf6, 0x90, 0x87, 0xb0, 0x0b, 0x09, 0x0b, 0x6b, 0x3f, 0xe2, 0x20, +0xe3, 0xf3, 0x8c, 0xe8, 0xab, 0xd7, 0x81, 0xd7, 0x80, 0x40, 0x20, 0x0c, +0x17, 0x72, 0x40, 0x1a, 0xdb, 0x6d, 0x5d, 0x20, 0x7a, 0x4a, 0xb8, 0x63, +0x7f, 0x4f, 0x4b, 0x1f, 0x15, 0x07, 0x15, 0x15, 0x1d, 0x0b, 0x3e, 0xe4, +0x88, 0xd7, 0x80, 0x40, 0x14, 0xc9, 0x2f, 0xb4, 0x78, 0x2c, 0xfe, 0x6e, +0x0b, 0x04, 0x7a, 0x11, 0x08, 0xf5, 0x86, 0xa8, 0x64, 0xea, 0xe7, 0xbc, +0xc3, 0x11, 0x71, 0xd0, 0xb2, 0x55, 0x1d, 0xcb, 0xe6, 0xdf, 0x72, 0x87, +0x42, 0x6b, 0x0b, 0x54, 0x07, 0xa2, 0x50, 0x7b, 0x7e, 0x61, 0x53, 0x9c, +0xc3, 0x38, 0x6e, 0x4f, 0x02, 0x21, 0x3f, 0x03, 0x02, 0xd1, 0xfe, 0xc6, +0xcb, 0x94, 0xa0, 0x1e, 0xaa, 0x70, 0x5a, 0xcb, 0x41, 0x79, 0xef, 0x1e, +0x5a, 0xa2, 0xc6, 0xee, 0xa9, 0xee, 0xf5, 0x89, 0xe7, 0xd9, 0xb5, 0x5d, +0x16, 0x37, 0xad, 0x25, 0xf9, 0x74, 0x72, 0xf5, 0xb0, 0xb0, 0xea, 0xcf, +0xc2, 0x42, 0xdb, 0x76, 0x4f, 0xad, 0xbd, 0xe2, 0xa0, 0x67, 0x5f, 0x34, +0xcf, 0xb0, 0x56, 0xc1, 0xe6, 0xc7, 0x3c, 0xe5, 0xac, 0xad, 0x79, 0x11, +0xb5, 0x37, 0xce, 0x33, 0x4d, 0xb4, 0x7a, 0x38, 0x7a, 0x3f, 0xbf, 0x5a, +0x54, 0x7b, 0x12, 0x88, 0xc1, 0xee, 0x28, 0xee, 0xe6, 0x9c, 0xc3, 0x91, +0x7e, 0x5a, 0xd6, 0xf3, 0xdd, 0xf1, 0x6f, 0x68, 0x9f, 0xd1, 0xcb, 0x8e, +0xb6, 0x94, 0x49, 0x5c, 0xde, 0x78, 0x0a, 0x3d, 0x0d, 0xa8, 0x79, 0xcf, +0x44, 0xeb, 0x41, 0x20, 0xb4, 0x72, 0x05, 0x81, 0x68, 0xef, 0x04, 0xbc, +0x2c, 0xf4, 0x7b, 0xde, 0x5b, 0x98, 0x6b, 0xd8, 0xf9, 0x7d, 0xa8, 0x60, +0x6a, 0x55, 0x24, 0x4a, 0x9d, 0xa8, 0xee, 0x58, 0x10, 0x2c, 0x2f, 0x0f, +0x24, 0x22, 0x10, 0x58, 0x69, 0x8f, 0x6f, 0x6f, 0x32, 0x3a, 0x0c, 0x29, +0x1d, 0xf9, 0x5e, 0x34, 0xe2, 0x6b, 0x97, 0x5b, 0x8e, 0x9c, 0x84, 0x11, +0x84, 0x51, 0x2e, 0xe4, 0x58, 0x8e, 0x4c, 0x52, 0x04, 0x02, 0xcb, 0x9d, +0x6b, 0x38, 0x13, 0x52, 0xba, 0xda, 0xd6, 0x3d, 0xd7, 0x85, 0x5c, 0x90, +0xc8, 0x9b, 0xb8, 0x3a, 0xb9, 0xe5, 0xdf, 0x6b, 0x57, 0xd8, 0x01, 0x3c, +0x84, 0x53, 0x61, 0x25, 0x04, 0x02, 0x2b, 0x9d, 0x6b, 0xd8, 0xeb, 0x01, +0xd8, 0xd3, 0xd0, 0x7b, 0xc3, 0x50, 0x7b, 0x37, 0x8c, 0x08, 0x45, 0xa3, +0x1e, 0x85, 0x0b, 0x2e, 0x00, 0xb2, 0xa6, 0x8b, 0x7f, 0x20, 0x02, 0x5a, +0x7a, 0x7a, 0x77, 0x54, 0x2c, 0x2c, 0xee, 0x84, 0x9b, 0x8f, 0x40, 0x60, +0x29, 0x4d, 0xcb, 0x57, 0xf7, 0x86, 0x94, 0xe4, 0xef, 0xaf, 0x9c, 0x86, +0x4e, 0xd5, 0x61, 0x19, 0xa1, 0x00, 0x42, 0x75, 0xbd, 0x0b, 0x04, 0x55, +0x4c, 0x75, 0x9f, 0x51, 0xd9, 0x2b, 0x0e, 0x36, 0xd7, 0x90, 0xeb, 0xa6, +0x40, 0x42, 0x4f, 0xd0, 0x7d, 0x78, 0xee, 0xca, 0xa2, 0xda, 0xcb, 0x49, +0x6a, 0x04, 0xa2, 0x5d, 0xcf, 0x61, 0xa3, 0x4d, 0x06, 0x6d, 0x73, 0x00, +0x72, 0xe4, 0x1b, 0x7a, 0x16, 0x08, 0x6d, 0xd6, 0xc7, 0x49, 0xea, 0x3a, +0x45, 0xfb, 0x95, 0x38, 0xd8, 0x96, 0xde, 0x35, 0x08, 0x3c, 0x1e, 0x05, +0x0c, 0x97, 0x6f, 0x70, 0x11, 0x4a, 0x0d, 0x6b, 0xcf, 0x3f, 0xd0, 0xac, +0xaf, 0xad, 0xb0, 0x92, 0xbd, 0xfa, 0xb3, 0xc6, 0xbb, 0x3c, 0xf0, 0x28, +0x60, 0x98, 0x7c, 0x83, 0x4b, 0x74, 0x53, 0x57, 0x4d, 0x3b, 0x55, 0xda, +0x7d, 0xb7, 0x25, 0x0e, 0xf2, 0xe7, 0xb5, 0x8f, 0x3d, 0xd3, 0x83, 0x8d, +0x96, 0x1d, 0x50, 0x3f, 0x31, 0xcf, 0x8d, 0xf4, 0x10, 0xb7, 0xb7, 0xd5, +0x2e, 0xdc, 0x28, 0xd7, 0xde, 0x01, 0xb8, 0x96, 0xf2, 0x29, 0x08, 0x05, +0xd4, 0xcc, 0x3d, 0xf6, 0xc9, 0x73, 0x15, 0x88, 0x1e, 0x76, 0xab, 0xe4, +0x1f, 0xea, 0x69, 0x9d, 0xd1, 0xb3, 0x50, 0x23, 0x14, 0x50, 0x25, 0xb1, +0xc5, 0x41, 0x13, 0xbb, 0x2d, 0xc7, 0xed, 0xf5, 0x67, 0x20, 0xbc, 0x54, +0xcf, 0x09, 0xe9, 0x35, 0x6f, 0x34, 0x68, 0x95, 0xbf, 0x20, 0x14, 0x00, +0x15, 0xe6, 0x1c, 0xdc, 0x46, 0xe5, 0x48, 0xeb, 0xe1, 0x0c, 0xca, 0x5b, +0xeb, 0x28, 0x67, 0x15, 0x91, 0xd0, 0x6e, 0xc8, 0xa6, 0x93, 0xc1, 0x14, +0x2e, 0xa2, 0xa5, 0x7a, 0xb0, 0xa5, 0x30, 0xff, 0xb3, 0xd0, 0x10, 0x10, +0xfa, 0x08, 0x2b, 0xb9, 0x8e, 0x12, 0xd4, 0x36, 0x39, 0x8d, 0x40, 0x94, +0x0d, 0xf3, 0xc9, 0x3b, 0xf0, 0x63, 0x75, 0x4f, 0xd5, 0xcf, 0xd4, 0xdb, +0x33, 0x40, 0x28, 0x20, 0x37, 0x49, 0xbb, 0xdd, 0xb6, 0x7e, 0x03, 0x9b, +0x2d, 0x6d, 0xd5, 0xff, 0xd6, 0xd6, 0xd1, 0xb2, 0x58, 0xc9, 0xef, 0xb5, +0x50, 0x25, 0xd3, 0x43, 0xde, 0xc1, 0x84, 0x96, 0x76, 0x97, 0x84, 0xb6, +0x74, 0x71, 0xd8, 0x09, 0xa1, 0xe0, 0xaa, 0x53, 0x48, 0x2b, 0x0e, 0xa9, +0x77, 0xc4, 0x47, 0x9a, 0xa6, 0xd5, 0x18, 0xd2, 0xd0, 0x3b, 0xa8, 0x6d, +0x6b, 0x86, 0x2d, 0x5b, 0x13, 0x0e, 0x15, 0x0f, 0xf9, 0x5a, 0xb5, 0x7a, +0x1f, 0xfa, 0xd9, 0xe4, 0x73, 0xda, 0xcf, 0xbd, 0x66, 0x25, 0x7e, 0x06, +0xfd, 0x5c, 0x7e, 0x51, 0x3c, 0x1a, 0x8b, 0xbf, 0xf5, 0x14, 0x6a, 0x72, +0x9c, 0xa1, 0x80, 0x4c, 0x2c, 0x2e, 0x53, 0x72, 0xb7, 0xd5, 0xdd, 0xb5, +0xad, 0xb3, 0xd7, 0x1d, 0xac, 0x0a, 0xc6, 0x33, 0xa1, 0x78, 0x25, 0x22, +0x2a, 0x9a, 0x6b, 0x42, 0xb2, 0x67, 0x91, 0x7e, 0x66, 0xfa, 0x75, 0xf5, +0x60, 0x98, 0x7e, 0xbf, 0x67, 0x76, 0xe4, 0xf3, 0x97, 0x10, 0x7b, 0xed, +0x9e, 0xec, 0xce, 0x27, 0x6a, 0x6f, 0xbd, 0x7a, 0x12, 0x8e, 0x44, 0x36, +0x44, 0x26, 0xdb, 0x64, 0xd1, 0xb6, 0xcb, 0xae, 0xe1, 0xc4, 0xb4, 0x2c, +0xb2, 0xa6, 0x9b, 0xef, 0xc3, 0x34, 0x39, 0xba, 0xb6, 0x28, 0xeb, 0xc2, +0x1c, 0x43, 0x4c, 0x72, 0x99, 0x7a, 0x3e, 0xd6, 0xc2, 0x9f, 0x49, 0xc5, +0x2c, 0xb7, 0x07, 0x21, 0x82, 0x79, 0x20, 0xe7, 0x50, 0x34, 0x9c, 0x5a, +0x91, 0x50, 0xe0, 0x51, 0xc0, 0x29, 0xee, 0x39, 0x27, 0x88, 0x2e, 0x3c, +0xad, 0xe6, 0x1d, 0x8c, 0xf7, 0xf3, 0x6c, 0x67, 0x76, 0xf3, 0x13, 0x72, +0x72, 0x1b, 0x2d, 0xe4, 0xe5, 0x99, 0x6f, 0xed, 0xf2, 0xd7, 0x2c, 0x5c, +0xac, 0xf7, 0x78, 0x01, 0x47, 0x4d, 0xbf, 0xb6, 0xf5, 0xee, 0x34, 0xd4, +0xb4, 0x72, 0xdf, 0xc9, 0xe2, 0x7f, 0xae, 0x29, 0xf7, 0x4e, 0xdc, 0x2f, +0x7a, 0x53, 0xec, 0xd0, 0xaa, 0xfc, 0x1c, 0x9d, 0x17, 0x1c, 0xe0, 0x51, +0xc0, 0x21, 0xe6, 0x9c, 0x13, 0xa2, 0xd5, 0xf0, 0x92, 0x2d, 0x69, 0xf5, +0xe1, 0x94, 0xd8, 0x89, 0xc0, 0xdb, 0x0b, 0xb3, 0x62, 0x33, 0x59, 0xcf, +0x65, 0xcd, 0x8b, 0xd9, 0x6b, 0x1b, 0x5f, 0xc7, 0x7e, 0x9f, 0xbb, 0xf9, +0x0c, 0x9b, 0xe4, 0xdc, 0x60, 0xf8, 0xf1, 0x9a, 0x32, 0x11, 0x2b, 0x3f, +0xeb, 0xd2, 0xab, 0x57, 0x91, 0xe1, 0xf9, 0x41, 0x0f, 0x5e, 0x43, 0x89, +0xf8, 0x6b, 0x6b, 0xe1, 0x25, 0xdb, 0x32, 0x5a, 0xc5, 0xc1, 0x3f, 0x37, +0x28, 0x24, 0x10, 0x99, 0x17, 0xb7, 0x7b, 0xaf, 0x62, 0x11, 0x31, 0x44, +0x07, 0xbd, 0x79, 0x0d, 0xa5, 0x06, 0xa5, 0x56, 0xfe, 0xb4, 0x12, 0x52, +0xb2, 0xb9, 0x02, 0x53, 0x6b, 0x8f, 0x8b, 0x5e, 0x4e, 0x20, 0x4a, 0xd6, +0xfa, 0xf7, 0x1a, 0x82, 0xc2, 0x9b, 0x80, 0xf2, 0xe2, 0xa0, 0x0b, 0x6e, +0x0b, 0x13, 0xcc, 0x86, 0x94, 0x10, 0x87, 0x3a, 0x04, 0xe2, 0xe8, 0x59, +0x87, 0xc4, 0x21, 0xa8, 0x77, 0xcf, 0xa2, 0x13, 0xc1, 0xe0, 0x90, 0x1d, +0xb8, 0x7b, 0xc9, 0xc1, 0xdc, 0x82, 0xf7, 0x60, 0x6f, 0x16, 0x53, 0x93, +0xcf, 0xec, 0xc3, 0x4a, 0x88, 0x43, 0x59, 0x0f, 0xa2, 0xd6, 0x9d, 0xee, +0xfb, 0x5d, 0xf6, 0x2d, 0x0b, 0x06, 0xa1, 0xd3, 0xb1, 0x29, 0x7a, 0x30, +0x48, 0x17, 0xde, 0x5a, 0x27, 0x8f, 0x36, 0x7b, 0x0b, 0xcb, 0x3c, 0xbd, +0xa0, 0xb1, 0xbb, 0x2a, 0x2c, 0x10, 0x8d, 0x2d, 0x5e, 0x77, 0x6f, 0xcd, +0x09, 0x06, 0x22, 0x31, 0x28, 0xa5, 0x0f, 0x04, 0x69, 0x0d, 0x7d, 0x0b, +0xc2, 0x10, 0x84, 0x94, 0x26, 0x46, 0x4f, 0x15, 0x1e, 0x44, 0xcb, 0xef, +0x41, 0x2b, 0xd0, 0x5a, 0x09, 0x49, 0xb1, 0x21, 0x1a, 0x8c, 0xa2, 0x2d, +0x8e, 0xd5, 0x7b, 0xa8, 0xa9, 0xb4, 0x55, 0x4f, 0x40, 0x87, 0x1e, 0x83, +0x08, 0x83, 0xff, 0x9c, 0x33, 0x21, 0xa5, 0x3a, 0x04, 0xa2, 0xc3, 0x5d, +0xed, 0x23, 0x24, 0x55, 0x79, 0xc2, 0x9b, 0xc4, 0xf5, 0x20, 0x4c, 0xae, +0x82, 0x84, 0x6f, 0x0d, 0xa5, 0xad, 0xb2, 0xf0, 0xeb, 0x81, 0xb3, 0xb5, +0x50, 0x92, 0x69, 0x74, 0x86, 0x30, 0xd4, 0xe5, 0x41, 0xf4, 0x5c, 0x8a, +0xf9, 0x9e, 0xbf, 0xa8, 0x50, 0x30, 0xf0, 0x9e, 0x3b, 0xe7, 0x5e, 0xc3, +0x80, 0x2b, 0x79, 0x72, 0xfa, 0x99, 0x28, 0x68, 0x27, 0x56, 0x84, 0xa1, +0x5e, 0x81, 0x18, 0x30, 0x26, 0xfe, 0x2e, 0x18, 0xe2, 0xf9, 0x97, 0x9c, +0xbf, 0x15, 0x55, 0x8d, 0x41, 0x83, 0xbb, 0xba, 0xc3, 0xf7, 0x26, 0xe4, +0x0c, 0x31, 0x85, 0x21, 0x24, 0x0d, 0x1f, 0x69, 0xf3, 0x3b, 0xd3, 0x2e, +0x02, 0x61, 0xa8, 0x74, 0xac, 0xf9, 0x05, 0x6a, 0xf4, 0x77, 0xa3, 0x82, +0x51, 0xe4, 0xb0, 0x1e, 0x49, 0xeb, 0x4e, 0xa9, 0xa9, 0x4b, 0xa5, 0xed, +0x7e, 0x9a, 0x5b, 0x20, 0x34, 0xa7, 0x60, 0x2e, 0x54, 0x99, 0xd9, 0x15, +0x35, 0x33, 0xde, 0x48, 0x96, 0xae, 0x44, 0x05, 0x9c, 0x6f, 0xa9, 0xe2, +0xc8, 0x47, 0xc0, 0x49, 0x8a, 0x1d, 0x86, 0x73, 0x2f, 0xee, 0x4f, 0xc8, +0xed, 0x32, 0x73, 0x81, 0x4a, 0x36, 0x52, 0x14, 0x42, 0x20, 0xe4, 0x3b, +0xc4, 0x22, 0x93, 0x67, 0xc1, 0xbb, 0xe8, 0x84, 0xc9, 0x55, 0x7a, 0xce, +0x40, 0xdb, 0x64, 0x17, 0x8a, 0xa5, 0x4e, 0x0c, 0x8d, 0x76, 0x36, 0x25, +0x7e, 0xd1, 0x83, 0x4a, 0xc4, 0x82, 0x2e, 0x02, 0x9d, 0xc4, 0x2b, 0x6b, +0x2b, 0x9b, 0xd3, 0xb3, 0x04, 0xf2, 0xab, 0xb6, 0xaf, 0x28, 0x75, 0xb9, +0x0c, 0xbb, 0xa0, 0xa6, 0x36, 0x26, 0x78, 0x7d, 0x17, 0xde, 0x45, 0xa2, +0x8a, 0x28, 0xde, 0x49, 0xcb, 0xd4, 0x94, 0x77, 0x58, 0x09, 0xed, 0x3c, +0xae, 0x31, 0xb5, 0x77, 0x39, 0x17, 0x10, 0x33, 0xbc, 0x88, 0x76, 0x04, +0x02, 0x31, 0x8f, 0xb0, 0x61, 0x8c, 0xb9, 0x26, 0xb0, 0xc9, 0xc2, 0xc5, +0x4f, 0x7d, 0xcd, 0xe1, 0x4d, 0x2f, 0xc9, 0xd1, 0x32, 0xd3, 0x9c, 0x22, +0x81, 0x9b, 0xdc, 0xc6, 0xf8, 0x23, 0xbc, 0x14, 0x9d, 0x68, 0xe5, 0xb2, +0x54, 0x35, 0x21, 0x0e, 0xa9, 0xfb, 0xcb, 0xdf, 0xd4, 0xfd, 0xd5, 0xf3, +0x09, 0x39, 0xcb, 0x5f, 0x11, 0x89, 0x74, 0x8b, 0x10, 0xa1, 0x8c, 0xba, +0x3d, 0xbc, 0x88, 0x9b, 0x31, 0x3c, 0xf1, 0x96, 0xdc, 0xc8, 0xd2, 0x79, +0x07, 0xe3, 0x35, 0x1c, 0xe1, 0x71, 0xcd, 0xa9, 0x1e, 0x64, 0xcb, 0x59, +0x02, 0xcb, 0x2e, 0xa8, 0x4e, 0x81, 0xd0, 0x6b, 0x4d, 0x09, 0x63, 0xd4, +0x2d, 0x12, 0x78, 0x78, 0x0d, 0x51, 0x32, 0xef, 0x10, 0xe9, 0x04, 0xf2, +0xa4, 0x42, 0x91, 0xb9, 0x57, 0x13, 0x35, 0xf6, 0x95, 0x09, 0x84, 0xbc, +0x7f, 0x0e, 0xc7, 0x35, 0xe3, 0x49, 0xe0, 0x45, 0x10, 0x5a, 0xca, 0x7a, +0xa7, 0xed, 0x54, 0xe0, 0xa4, 0x28, 0xa1, 0x8c, 0x4a, 0x04, 0x42, 0x3d, +0x49, 0xbc, 0xbb, 0x36, 0x44, 0x82, 0xf7, 0x44, 0x68, 0xe9, 0xd9, 0xce, +0x3b, 0xe5, 0x0e, 0x6f, 0xce, 0xf5, 0x73, 0xb1, 0x5b, 0x8d, 0xc7, 0x55, +0x71, 0x97, 0x10, 0x23, 0x77, 0x6f, 0x34, 0xb7, 0xb9, 0xc4, 0x8b, 0xe8, +0xd9, 0xa5, 0xaf, 0xc0, 0x6b, 0xd8, 0x14, 0xbf, 0x5c, 0x3f, 0x1f, 0x3b, +0xa1, 0x3a, 0x04, 0xc2, 0xb4, 0x59, 0x27, 0xff, 0x90, 0xd1, 0x93, 0x70, +0x84, 0x69, 0x79, 0xb1, 0x2e, 0x4f, 0x75, 0x52, 0x92, 0x9f, 0x33, 0x53, +0x8e, 0x85, 0x81, 0x5e, 0xd0, 0x9b, 0xd5, 0x4b, 0x9b, 0x48, 0x7e, 0xb6, +0x15, 0x6e, 0xe2, 0x7d, 0x55, 0x4a, 0xe6, 0xc4, 0x74, 0xea, 0x90, 0x52, +0x2d, 0x42, 0x41, 0x3e, 0xe2, 0x9a, 0xc7, 0x77, 0xb9, 0xb1, 0x22, 0x0b, +0x4e, 0x31, 0xee, 0x67, 0x3c, 0x40, 0x42, 0xb4, 0x9d, 0x29, 0xfe, 0x89, +0x97, 0x3f, 0x55, 0xf6, 0xb3, 0xa7, 0xce, 0x4f, 0x20, 0x12, 0x05, 0x3c, +0x08, 0x53, 0xe6, 0x8c, 0x27, 0xd7, 0xd0, 0xfc, 0x22, 0x3c, 0x5b, 0x21, +0x39, 0x2a, 0x7d, 0xfc, 0x8b, 0xaf, 0x35, 0x16, 0x7c, 0x4f, 0xe5, 0x4d, +0x50, 0x83, 0x7f, 0xfe, 0x9d, 0x5c, 0x79, 0xee, 0xe6, 0x3a, 0xda, 0x89, +0x47, 0x59, 0xc5, 0xbb, 0x5c, 0x5e, 0xf5, 0x72, 0x2a, 0x18, 0x76, 0x86, +0x67, 0x0a, 0xef, 0xfa, 0x49, 0x44, 0x5f, 0x25, 0x49, 0x12, 0x9b, 0x5d, +0xd1, 0x39, 0xaf, 0xd6, 0x5d, 0xc8, 0x3f, 0x98, 0x36, 0xf0, 0x84, 0x2b, +0x2a, 0xf3, 0x0c, 0xfd, 0xbb, 0x5d, 0x02, 0xe3, 0x92, 0xad, 0xd1, 0xbc, +0x87, 0x46, 0x5b, 0x62, 0xa7, 0x0a, 0x39, 0x11, 0x6a, 0xca, 0xe4, 0x41, +0x68, 0xbb, 0x15, 0xf2, 0x0f, 0x00, 0x95, 0x7a, 0x0f, 0x95, 0x87, 0x94, +0x5e, 0xee, 0x72, 0x62, 0x87, 0x9c, 0xd8, 0xcd, 0xe6, 0xf3, 0x20, 0xc8, +0x3f, 0x00, 0x54, 0xea, 0x3d, 0x9c, 0xec, 0xa1, 0x34, 0x44, 0xc8, 0x89, +0x50, 0x53, 0x1e, 0x81, 0x10, 0x71, 0xa0, 0x81, 0x22, 0x40, 0x45, 0x8b, +0x5f, 0x07, 0x5e, 0x43, 0x2e, 0x2f, 0x8b, 0x50, 0x53, 0xe2, 0xe7, 0x2e, +0x39, 0x08, 0xc4, 0x18, 0xe0, 0x42, 0x08, 0x25, 0x41, 0x9c, 0xbd, 0x67, +0x77, 0x3e, 0x76, 0x5e, 0x82, 0x4a, 0x8d, 0x84, 0x1b, 0x18, 0xc2, 0x4b, +0x00, 0x95, 0x78, 0x0f, 0x8d, 0x55, 0x29, 0x5d, 0x0a, 0x79, 0x70, 0x41, +0x4a, 0x3e, 0xce, 0xe6, 0x80, 0x4c, 0x07, 0x5f, 0x3c, 0x35, 0x80, 0x92, +0xde, 0x83, 0xde, 0x0d, 0x3d, 0xd0, 0xb3, 0xe3, 0x82, 0x94, 0x4c, 0x9c, +0xcd, 0x8f, 0x89, 0xf7, 0x40, 0xff, 0x25, 0x80, 0x0b, 0xe1, 0x92, 0x88, +0xe2, 0x30, 0x62, 0x12, 0x70, 0x72, 0x54, 0x35, 0x55, 0x2b, 0x10, 0xe6, +0x82, 0x20, 0x00, 0x38, 0x4a, 0xc4, 0xdb, 0x9f, 0x46, 0x5e, 0xdc, 0xa2, +0x88, 0x04, 0x61, 0x90, 0xf8, 0x02, 0xe1, 0x68, 0xf8, 0x06, 0x50, 0xce, +0x7b, 0xa0, 0x75, 0x44, 0xbc, 0x67, 0x89, 0xd0, 0x6e, 0x72, 0xa9, 0x51, +0x1f, 0x39, 0x1e, 0x80, 0xcc, 0xbb, 0x32, 0x47, 0x05, 0x4e, 0x12, 0x91, +0x70, 0xe4, 0x22, 0x56, 0x05, 0xe2, 0xa2, 0xa7, 0x8b, 0x67, 0x06, 0x90, +0x79, 0xd2, 0x31, 0xf1, 0x56, 0x88, 0x70, 0xe2, 0x9a, 0x72, 0xcc, 0xcf, +0xdc, 0x1d, 0xa2, 0x0b, 0x90, 0x95, 0x29, 0xc2, 0x6e, 0x97, 0x70, 0xc8, +0x8a, 0xf0, 0x12, 0x2f, 0xaf, 0xce, 0x33, 0x63, 0x23, 0x03, 0x70, 0x90, +0x18, 0x67, 0x1f, 0xd8, 0xed, 0x6e, 0xec, 0x78, 0x2f, 0x7a, 0x67, 0x84, +0xed, 0x22, 0x6e, 0x66, 0x10, 0x5d, 0x80, 0x32, 0x02, 0xc1, 0xee, 0x2c, +0xc2, 0xae, 0x57, 0xc4, 0xc4, 0xd7, 0xea, 0x13, 0x12, 0x49, 0xe3, 0x41, +0xb0, 0x99, 0x01, 0x28, 0x30, 0xe9, 0x58, 0xd0, 0x9e, 0x70, 0x24, 0x1f, +0xe1, 0xdb, 0x41, 0x20, 0xba, 0x09, 0x3c, 0x08, 0xc6, 0x29, 0x40, 0xb9, +0x49, 0xc7, 0xa2, 0xb6, 0xcd, 0xee, 0x50, 0x93, 0xb4, 0xa4, 0x66, 0xb7, +0x1b, 0x47, 0x6c, 0x1d, 0x87, 0x11, 0x01, 0xaa, 0x13, 0x08, 0x44, 0xe2, +0xa4, 0xa7, 0x26, 0x0b, 0x17, 0x02, 0x91, 0x67, 0xbc, 0x72, 0x26, 0x02, +0xa0, 0x9c, 0x40, 0x20, 0x12, 0x27, 0x76, 0xbf, 0x12, 0x5e, 0x92, 0x1b, +0xcf, 0x10, 0x88, 0xe7, 0xde, 0x18, 0x63, 0x14, 0xa0, 0x7d, 0x81, 0x20, +0xd6, 0xfb, 0x99, 0xa7, 0x67, 0x4e, 0x44, 0x1c, 0x02, 0x81, 0x60, 0x01, +0x5b, 0x21, 0xf2, 0x85, 0x56, 0x8c, 0x51, 0x80, 0x12, 0x02, 0x41, 0xcb, +0x88, 0xf5, 0xe7, 0xbd, 0x26, 0x12, 0xe2, 0x3d, 0xfc, 0xfe, 0xfd, 0xfb, +0x4d, 0xab, 0x98, 0x28, 0xc9, 0x7c, 0xee, 0x45, 0x5c, 0x3d, 0xdc, 0xa9, +0x15, 0x63, 0x8c, 0x51, 0x80, 0x72, 0x1e, 0x04, 0x3b, 0xb4, 0x75, 0x16, +0xb7, 0x92, 0x7b, 0x08, 0x4a, 0x5c, 0xf1, 0x1e, 0x12, 0x8f, 0x5b, 0x73, +0x47, 0x04, 0x63, 0x14, 0x60, 0x83, 0xd8, 0x57, 0x67, 0x22, 0x10, 0x27, +0x44, 0xc2, 0x51, 0xab, 0x1f, 0xfb, 0x19, 0xee, 0x12, 0x08, 0xf1, 0xdc, +0x48, 0x58, 0x03, 0xbc, 0x10, 0x89, 0xc8, 0x71, 0x5d, 0x4e, 0x03, 0xef, +0x7c, 0xee, 0xe6, 0x9e, 0x02, 0x2d, 0xbf, 0x44, 0x1c, 0x0e, 0xb0, 0xb7, +0xec, 0xd5, 0x3e, 0x67, 0xfb, 0x7b, 0x92, 0xf3, 0x21, 0xcc, 0x04, 0xb0, +0xd3, 0x6d, 0x97, 0x09, 0x17, 0xf1, 0x76, 0x34, 0x16, 0xbb, 0xd7, 0xdc, +0xbc, 0x88, 0xde, 0x59, 0xa4, 0xce, 0x21, 0x9e, 0xc0, 0xab, 0x31, 0x6b, +0x6e, 0x94, 0xfb, 0xe0, 0x41, 0x48, 0xde, 0x87, 0x56, 0xf5, 0x00, 0xc7, +0x17, 0xad, 0x49, 0x16, 0x78, 0xd9, 0x5d, 0xad, 0xed, 0xbe, 0x10, 0x07, +0xa8, 0x69, 0x63, 0x23, 0x8b, 0xbd, 0xe4, 0x71, 0x44, 0x08, 0xc2, 0xb1, +0x2a, 0xbf, 0xff, 0xeb, 0xd7, 0xaf, 0x37, 0xfb, 0xfb, 0xf2, 0xdf, 0xf2, +0x7b, 0xf2, 0x67, 0x1c, 0x9c, 0x03, 0xb8, 0x2e, 0x18, 0x2a, 0x1a, 0x62, +0xb3, 0xb7, 0x45, 0x3c, 0x0e, 0x6b, 0x5e, 0x18, 0x26, 0x1e, 0x19, 0x94, +0x12, 0x09, 0x2d, 0x17, 0x16, 0x13, 0x11, 0x10, 0x2f, 0xc1, 0x78, 0x0a, +0xef, 0xb9, 0x07, 0x23, 0x26, 0x8c, 0x57, 0x00, 0x80, 0x01, 0x36, 0x32, +0xb3, 0x6c, 0x54, 0xf4, 0xd0, 0xa1, 0x08, 0x84, 0x98, 0x0a, 0x82, 0x86, +0x9a, 0x4c, 0xbe, 0x87, 0xd0, 0x12, 0x00, 0xc0, 0x68, 0x1e, 0x85, 0x8a, +0x85, 0xf7, 0x6c, 0xd5, 0xfb, 0x5d, 0x10, 0x06, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2a, 0xb8, +0xff, 0xb1, 0x1b, 0x8f, 0x01, 0x00, 0x00, 0x2c, 0x22, 0x0c, 0x0b, 0x8f, +0x01, 0x00, 0x00, 0x3e, 0x78, 0x0e, 0x5f, 0xbe, 0x7c, 0xf9, 0xef, 0x9f, +0x5f, 0x67, 0x1e, 0x05, 0x00, 0x00, 0x84, 0xe2, 0xf0, 0xe6, 0x08, 0x2f, +0x01, 0x00, 0x80, 0x67, 0xf9, 0xf6, 0xed, 0xdb, 0xff, 0x44, 0x1c, 0xbe, +0x7e, 0xfd, 0xfa, 0x1f, 0x1e, 0x07, 0x00, 0xc0, 0xe0, 0x1e, 0xc3, 0x1f, +0x9b, 0x8d, 0xd7, 0xa0, 0x46, 0x78, 0x09, 0x00, 0x60, 0x10, 0x6e, 0x5e, +0x0c, 0x26, 0x6f, 0xcb, 0x8a, 0x28, 0x3c, 0xcc, 0x7b, 0x11, 0x84, 0x97, +0x00, 0x00, 0x3a, 0x17, 0x83, 0x59, 0xc2, 0x45, 0x1a, 0x3a, 0xda, 0x69, +0x78, 0x0f, 0x00, 0x00, 0x1d, 0x71, 0x3f, 0x29, 0x06, 0x78, 0x0f, 0x00, +0x00, 0x1d, 0x7b, 0x0b, 0xf3, 0x15, 0x51, 0x08, 0x8c, 0xb3, 0x0f, 0x00, +0x00, 0x8d, 0x7b, 0x0b, 0x8f, 0x1c, 0x42, 0x44, 0x61, 0x50, 0xc3, 0x7b, +0x00, 0x00, 0x68, 0xd1, 0x53, 0x48, 0x24, 0x0a, 0x78, 0x0f, 0x00, 0x00, +0x8d, 0xf2, 0x08, 0x21, 0x89, 0xfd, 0xf8, 0xf1, 0xe3, 0x9f, 0xef, 0xdf, +0xbf, 0xff, 0x13, 0x5b, 0x1c, 0x7c, 0x45, 0x13, 0x00, 0x00, 0x34, 0x84, +0xec, 0xea, 0xdf, 0x44, 0x18, 0x7e, 0xfd, 0xfa, 0xf5, 0xf8, 0x35, 0xb6, +0x38, 0x78, 0x8f, 0xe4, 0xce, 0xa3, 0x06, 0x00, 0x68, 0x04, 0x7f, 0x9a, +0xf9, 0xed, 0xe7, 0xcf, 0x9f, 0x6f, 0xbf, 0x7f, 0xff, 0x4e, 0x22, 0x0e, +0x8e, 0x53, 0xd3, 0x00, 0x00, 0x4d, 0xf1, 0xe8, 0x87, 0xb4, 0x2c, 0xcb, +0x9b, 0x78, 0x0d, 0x22, 0x10, 0x29, 0xc2, 0x4a, 0x46, 0x1c, 0x48, 0x4c, +0x03, 0x00, 0x34, 0xc0, 0x24, 0x21, 0x1f, 0x11, 0x07, 0xf1, 0x1a, 0x44, +0x1c, 0x5c, 0x9a, 0x84, 0x34, 0x67, 0x1e, 0x00, 0x00, 0x5a, 0x15, 0x07, +0xf1, 0x1e, 0x52, 0x79, 0x0e, 0xf2, 0x75, 0xfd, 0xd7, 0x26, 0xf7, 0x00, +0x00, 0x50, 0x39, 0xd2, 0xde, 0xe2, 0x4d, 0xc5, 0x21, 0x55, 0xce, 0x41, +0x04, 0x48, 0x84, 0x41, 0xc4, 0x47, 0xbe, 0x87, 0x17, 0x09, 0xf9, 0xde, +0x93, 0xff, 0xd5, 0xfe, 0x37, 0xe2, 0x01, 0x00, 0x50, 0x98, 0xc5, 0x8a, +0x43, 0x4a, 0xcf, 0x41, 0xcf, 0x50, 0x68, 0x55, 0x94, 0x8a, 0xc4, 0xd6, +0xd9, 0x0a, 0x5f, 0xfe, 0xba, 0x18, 0xe1, 0x38, 0x2a, 0x1a, 0x13, 0xaf, +0x17, 0x00, 0xe0, 0x04, 0x92, 0x24, 0x96, 0x05, 0x5a, 0x2b, 0x95, 0x52, +0x26, 0xa4, 0xd7, 0xc4, 0xe2, 0x68, 0x85, 0x94, 0x17, 0x92, 0x25, 0xf0, +0x36, 0xac, 0x68, 0xdc, 0xbd, 0x4d, 0x3e, 0x01, 0xce, 0xe1, 0x3b, 0x00, +0xa8, 0x8a, 0x9b, 0x09, 0x93, 0x2c, 0x1b, 0x36, 0x79, 0xbb, 0x15, 0xfc, +0x8c, 0x8b, 0x0d, 0xf7, 0xc8, 0xaf, 0x09, 0x4f, 0x49, 0x6f, 0x9a, 0x7e, +0xff, 0xb3, 0xdf, 0x5b, 0xfe, 0x9d, 0x78, 0x1a, 0xf6, 0x94, 0xb7, 0xff, +0x95, 0xae, 0xb0, 0x00, 0x50, 0x05, 0x2f, 0xbb, 0x99, 0xca, 0x62, 0x2c, +0x3b, 0x65, 0x09, 0xe5, 0xa8, 0xe9, 0xc9, 0x64, 0xbf, 0xdb, 0x9d, 0x8d, +0x70, 0xc4, 0x8a, 0xbf, 0xdf, 0xc2, 0x5d, 0xb5, 0x2e, 0xa6, 0xfa, 0x79, +0xc4, 0x4a, 0x08, 0x83, 0x5d, 0xe0, 0xb5, 0x9c, 0x36, 0xe2, 0xd7, 0x45, +0x1c, 0x00, 0xa0, 0x0e, 0x51, 0x70, 0x27, 0xaa, 0x78, 0x34, 0xbc, 0xa2, +0xbb, 0x77, 0xf9, 0x7f, 0x15, 0x0d, 0xd3, 0xd2, 0x22, 0x8c, 0xbf, 0x87, +0x36, 0x59, 0x6f, 0x45, 0x05, 0x40, 0x7f, 0xd5, 0x16, 0x19, 0xa5, 0x16, +0xff, 0x23, 0xcf, 0xc3, 0x24, 0xad, 0x63, 0xb4, 0xed, 0x20, 0xc1, 0x0d, +0x00, 0x65, 0x42, 0x47, 0xb2, 0x00, 0xc7, 0xe8, 0x4b, 0x14, 0x0a, 0x45, +0x68, 0x2a, 0x1c, 0xa9, 0x7a, 0x20, 0xd5, 0x64, 0xf2, 0xb3, 0x8a, 0x40, +0x3a, 0xce, 0x56, 0x00, 0x7c, 0x5a, 0x78, 0xce, 0x18, 0xe4, 0xf3, 0x14, +0x1e, 0xed, 0xad, 0x65, 0xa1, 0x96, 0x05, 0x5b, 0x17, 0xed, 0x58, 0x8b, +0xa3, 0x2d, 0x2f, 0x7d, 0x66, 0x6b, 0x5e, 0x46, 0x2f, 0xc2, 0xa1, 0xf9, +0x90, 0x2b, 0xb9, 0x08, 0x3c, 0x07, 0x68, 0x71, 0xc7, 0xf9, 0x1e, 0x02, +0x50, 0xb3, 0xb1, 0x60, 0x0d, 0x03, 0x1c, 0x35, 0xfd, 0xf7, 0xa1, 0xb9, +0x8f, 0xc9, 0x50, 0x1b, 0x9e, 0x40, 0x64, 0xf6, 0xbd, 0xb3, 0xf7, 0xd0, +0x91, 0x15, 0x05, 0xdd, 0xd1, 0xa7, 0xea, 0x49, 0x64, 0x13, 0xc6, 0xcf, +0xcc, 0x7a, 0x15, 0x2d, 0x84, 0x8f, 0x8e, 0x0a, 0xe5, 0x19, 0xc1, 0x43, +0x1c, 0xa0, 0x89, 0xd0, 0x83, 0x33, 0x17, 0xa9, 0xd4, 0x36, 0x79, 0x9f, +0x89, 0x8c, 0x29, 0x09, 0xb4, 0xa2, 0xb2, 0x25, 0x2c, 0x3d, 0x79, 0x6d, +0x1f, 0xc4, 0x40, 0x13, 0xb7, 0xb2, 0x00, 0x87, 0x8b, 0xb5, 0x2c, 0x5e, +0x39, 0xde, 0xa9, 0x7c, 0xff, 0x50, 0x14, 0x74, 0xe1, 0xec, 0x4d, 0x10, +0xd6, 0xc6, 0xe8, 0xd1, 0xe7, 0x8c, 0x38, 0x40, 0xd1, 0x05, 0xff, 0x99, +0x5d, 0xbd, 0x83, 0xb7, 0x95, 0x49, 0x1b, 0x8a, 0x8a, 0xfc, 0xdc, 0xd6, +0x0b, 0xda, 0x10, 0x1a, 0x5b, 0xce, 0xa9, 0x96, 0xd3, 0x8b, 0xb1, 0xdf, +0x63, 0xb2, 0x42, 0x60, 0xc5, 0x40, 0x16, 0xa4, 0x35, 0x41, 0xc8, 0x2d, +0x0c, 0x6b, 0xde, 0x44, 0xa9, 0xd2, 0xd3, 0x92, 0xa6, 0xe1, 0x33, 0xb7, +0x3f, 0x21, 0x8d, 0x27, 0x0c, 0x69, 0xc2, 0x08, 0xba, 0xc8, 0x87, 0x21, +0x9f, 0x91, 0x26, 0x64, 0x8c, 0xc5, 0x4c, 0x27, 0x75, 0x18, 0x1b, 0xb7, +0xe1, 0x02, 0xfd, 0x7f, 0x2b, 0x36, 0xfa, 0x7b, 0x6b, 0x62, 0x63, 0x45, +0x67, 0x8f, 0x85, 0xff, 0x46, 0xbf, 0xb6, 0x2d, 0x2d, 0xd5, 0xfc, 0xc1, +0x9e, 0x30, 0xce, 0xd9, 0x70, 0x87, 0x8b, 0xdf, 0xaf, 0x68, 0xc8, 0x31, +0xb5, 0xe3, 0xef, 0x71, 0x08, 0x0e, 0xa2, 0x79, 0x03, 0x8b, 0x2d, 0xfd, +0x63, 0x61, 0x2f, 0xe7, 0x89, 0xac, 0x2d, 0x82, 0x36, 0x7c, 0x62, 0x7f, +0x6f, 0xaf, 0xd9, 0xb3, 0x05, 0xd6, 0x23, 0xd8, 0x13, 0xd3, 0x0f, 0x93, +0xc0, 0x3d, 0xc6, 0xf6, 0x7b, 0x1b, 0x47, 0x8e, 0x73, 0x0e, 0x80, 0x18, +0x60, 0x31, 0x16, 0x13, 0x2b, 0x24, 0xe1, 0x41, 0x35, 0x15, 0x93, 0x11, +0xca, 0x48, 0x5b, 0x7c, 0x77, 0x2b, 0xe1, 0x4b, 0x9a, 0xf8, 0xc1, 0x21, +0xa6, 0x51, 0x72, 0x01, 0x18, 0x36, 0xa0, 0x21, 0x06, 0x70, 0x4e, 0x14, +0x7c, 0x82, 0x8a, 0x49, 0x84, 0x61, 0x0d, 0xe7, 0x1a, 0x5e, 0x6c, 0xec, +0x08, 0x25, 0xc1, 0xae, 0xd0, 0xd1, 0x8c, 0x28, 0x60, 0x58, 0x3f, 0x79, +0x28, 0xed, 0xc1, 0x84, 0x40, 0xc0, 0x69, 0x51, 0x20, 0x74, 0x84, 0x61, +0xfd, 0x94, 0xaf, 0xda, 0xbb, 0x26, 0xf4, 0xff, 0x1d, 0x4d, 0xf7, 0xe0, +0x68, 0xf8, 0x08, 0x51, 0xc0, 0xb0, 0x7e, 0xc2, 0x48, 0xb6, 0xb4, 0x58, +0x05, 0x42, 0xdb, 0x8b, 0x38, 0x4a, 0x59, 0x61, 0x07, 0x77, 0x3f, 0x18, +0x98, 0x54, 0x18, 0xd6, 0x91, 0xd7, 0x10, 0x76, 0xad, 0x75, 0xa6, 0x39, +0xdf, 0x2b, 0x0f, 0xc2, 0x87, 0x94, 0x61, 0x64, 0x8f, 0xe1, 0x4c, 0xbb, +0x64, 0x0c, 0xc3, 0xea, 0xef, 0xab, 0xa4, 0xbd, 0xab, 0xc2, 0x7b, 0xae, +0xf5, 0xf7, 0x5e, 0x09, 0x04, 0xdd, 0x59, 0x07, 0xce, 0x31, 0x20, 0x0c, +0x18, 0xd6, 0xaf, 0xe7, 0x60, 0x43, 0x4a, 0x7a, 0x06, 0x45, 0xff, 0xdc, +0x5e, 0x71, 0xfa, 0xec, 0xeb, 0xf8, 0x35, 0x02, 0x06, 0x4b, 0x3e, 0x93, +0x63, 0xc0, 0xb0, 0x8e, 0x2b, 0x95, 0xec, 0x09, 0xf6, 0x50, 0x04, 0xe4, +0xcf, 0xb7, 0xfe, 0x8c, 0x1c, 0xc4, 0xe0, 0xa1, 0x24, 0x84, 0x01, 0xc3, +0xc6, 0xf1, 0x1e, 0xd6, 0xee, 0xba, 0x5e, 0x0b, 0x39, 0x39, 0xaa, 0x98, +0x86, 0xf5, 0x16, 0x66, 0xce, 0x2e, 0x60, 0xd8, 0x58, 0x16, 0x36, 0x44, +0xb4, 0x9e, 0x82, 0xbd, 0x1c, 0x69, 0x47, 0x7b, 0x13, 0x04, 0xa2, 0x57, +0x51, 0xc0, 0x5b, 0xc0, 0xb0, 0xb1, 0xcb, 0x5b, 0x6d, 0xa8, 0x49, 0x6f, +0xc2, 0xd3, 0xdf, 0xdb, 0x71, 0x06, 0x02, 0x81, 0x20, 0x84, 0x84, 0x61, +0x58, 0xef, 0x42, 0xb1, 0x76, 0xa5, 0xea, 0x8e, 0xfc, 0x03, 0x02, 0xd1, +0x38, 0x77, 0xed, 0x9a, 0x5a, 0xeb, 0xe0, 0x5c, 0xb9, 0xc4, 0xe6, 0x8d, +0xae, 0x9d, 0x18, 0x56, 0xb6, 0xbb, 0xee, 0x81, 0xee, 0xb9, 0x08, 0x44, +0x83, 0xcc, 0xb5, 0x96, 0xa8, 0x9a, 0x3b, 0x99, 0x3f, 0xb5, 0x05, 0xd6, +0x9d, 0x0c, 0x02, 0x81, 0x61, 0x6d, 0x18, 0x65, 0xae, 0x6d, 0xe5, 0x16, +0xaa, 0x6b, 0x96, 0xe7, 0x43, 0x5a, 0xf6, 0x1e, 0xe5, 0xd5, 0xcf, 0x1e, +0xf6, 0x81, 0xc1, 0x30, 0xac, 0x19, 0x9b, 0x58, 0x7e, 0x11, 0x86, 0x43, +0xa2, 0x60, 0x2e, 0x0f, 0x79, 0x75, 0xca, 0x72, 0x12, 0x51, 0xd0, 0x24, +0x19, 0x93, 0x0d, 0xc3, 0xda, 0x32, 0xda, 0x6d, 0xd4, 0x2b, 0x0c, 0x55, +0x95, 0xa8, 0x9a, 0xf0, 0xd1, 0xde, 0x4b, 0x44, 0x6e, 0xf2, 0x6f, 0xf6, +0xf4, 0x7c, 0xc1, 0x30, 0xac, 0xfa, 0x50, 0x13, 0x97, 0x07, 0xd5, 0x90, +0x78, 0x76, 0x95, 0x9d, 0x74, 0x36, 0xde, 0xc2, 0x51, 0x16, 0xad, 0x9e, +0xd8, 0x71, 0x20, 0x07, 0xc3, 0xb0, 0xfa, 0x3d, 0x09, 0xfa, 0x32, 0x15, +0xf2, 0x16, 0xaa, 0x2a, 0x53, 0x3d, 0xe1, 0x2d, 0x7c, 0xc2, 0x1e, 0xf9, +0x27, 0xf7, 0x80, 0x61, 0x24, 0xad, 0xe1, 0x18, 0x53, 0x4d, 0xde, 0x82, +0xc9, 0x2d, 0xc4, 0x70, 0x25, 0x67, 0xf5, 0x1e, 0x76, 0xd6, 0x5b, 0x63, +0x18, 0xd6, 0x86, 0x51, 0xfa, 0x4a, 0x6e, 0xe1, 0x1a, 0x9a, 0x7b, 0x20, +0xbc, 0x84, 0x61, 0x78, 0x11, 0xd0, 0x58, 0x08, 0xc9, 0x78, 0x0b, 0x53, +0x8a, 0x9f, 0x57, 0x2b, 0x97, 0x08, 0x2f, 0x61, 0x58, 0x77, 0x46, 0x87, +0xd7, 0x58, 0xa2, 0x50, 0x5b, 0xc2, 0xd9, 0x7b, 0x0b, 0x7b, 0xca, 0x53, +0x2f, 0x85, 0xce, 0xf6, 0x5e, 0x48, 0x82, 0x61, 0x58, 0x5b, 0x27, 0xb1, +0x49, 0x54, 0x77, 0xe4, 0x29, 0xb8, 0x32, 0x65, 0x6a, 0xef, 0x02, 0x41, +0xfe, 0x01, 0xc3, 0xba, 0x33, 0xca, 0x5d, 0x0f, 0xf0, 0x28, 0x4b, 0xad, +0xb1, 0x7b, 0xaa, 0x39, 0xe5, 0x9c, 0xf5, 0x85, 0x8a, 0x18, 0xa9, 0x40, +0x70, 0x38, 0x0e, 0xc3, 0xf0, 0x20, 0x46, 0x0c, 0x1d, 0x55, 0x7b, 0xcf, +0x42, 0x29, 0x61, 0xf0, 0x48, 0xf8, 0xea, 0xfd, 0x52, 0x12, 0x12, 0xd4, +0x18, 0x46, 0xfe, 0xa1, 0x67, 0x31, 0x78, 0xcf, 0x25, 0x34, 0x72, 0xc7, +0xc2, 0x52, 0x50, 0xe1, 0x6f, 0xfa, 0x7c, 0x10, 0x08, 0x0c, 0xc3, 0x7b, +0xe8, 0x31, 0x5c, 0x34, 0x6b, 0x0b, 0x6d, 0x79, 0x20, 0xad, 0xdc, 0xaf, +0xe0, 0xbd, 0x99, 0xd2, 0xb1, 0xc1, 0x45, 0x3f, 0x8f, 0x0a, 0x04, 0x15, +0x4c, 0x18, 0xd6, 0x8d, 0x38, 0x0c, 0x91, 0x7b, 0xb8, 0xf9, 0x30, 0xc8, +0x22, 0x42, 0xa0, 0x62, 0xd0, 0xf8, 0xb5, 0x9c, 0x4b, 0x05, 0xca, 0x3e, +0xd9, 0xcf, 0x84, 0x40, 0x60, 0x18, 0xe2, 0xd0, 0x1a, 0x73, 0x2f, 0x37, +0xae, 0x15, 0xce, 0x33, 0x6c, 0x86, 0x96, 0x10, 0x08, 0x0c, 0xeb, 0xce, +0xa6, 0x21, 0x3c, 0x87, 0x1e, 0xc4, 0x21, 0xd3, 0x39, 0x86, 0x53, 0x89, +0x69, 0x04, 0x02, 0xc3, 0xba, 0xf3, 0x1c, 0x86, 0x69, 0xab, 0x31, 0x75, +0xe0, 0x2d, 0xd4, 0x26, 0x0c, 0x8f, 0xbc, 0xcd, 0x9a, 0xf0, 0x22, 0x10, +0x18, 0xf6, 0xdc, 0x64, 0x8e, 0x48, 0x19, 0xb8, 0x9c, 0x15, 0x52, 0x93, +0xff, 0xaf, 0xa8, 0xb0, 0x63, 0x72, 0x03, 0xd1, 0x9c, 0x40, 0x1c, 0xb8, +0x94, 0xa7, 0x18, 0x5b, 0x57, 0x9f, 0x22, 0x10, 0x58, 0x2f, 0xe1, 0xdc, +0x98, 0x26, 0xf3, 0x41, 0x84, 0x40, 0xfb, 0x94, 0xe9, 0x61, 0x52, 0x15, +0x87, 0x70, 0xbe, 0x68, 0x4b, 0x9c, 0x9c, 0x87, 0x6f, 0x7d, 0x94, 0x62, +0x28, 0x71, 0x78, 0xd0, 0xc2, 0x80, 0x8d, 0xdc, 0x51, 0x35, 0x7b, 0x68, +0xc9, 0x4e, 0x04, 0xca, 0x5c, 0xc7, 0xde, 0x1d, 0xb3, 0x39, 0xf8, 0x2c, +0x0c, 0xda, 0x7e, 0x46, 0xfe, 0x7b, 0xcf, 0xf3, 0x09, 0x1a, 0xe3, 0x7d, +0x28, 0xb0, 0x49, 0xb1, 0x9e, 0x8d, 0x94, 0x90, 0x5e, 0x63, 0xa9, 0x5c, +0x14, 0xaa, 0xf6, 0x16, 0x8e, 0x3c, 0x4b, 0xf9, 0x99, 0x7a, 0x3a, 0x49, +0xdd, 0x52, 0xc9, 0x73, 0x2d, 0xa1, 0x13, 0x9e, 0xc5, 0x47, 0x61, 0x90, +0x5f, 0x8f, 0x6e, 0x98, 0x76, 0x74, 0x4e, 0xbd, 0xab, 0x60, 0x5c, 0xad, +0xc4, 0x4c, 0xd8, 0xbc, 0xb3, 0x1d, 0x4a, 0x97, 0xb3, 0xca, 0x22, 0x63, +0xca, 0x6a, 0x17, 0xff, 0x42, 0x5a, 0x3b, 0x7c, 0x32, 0xef, 0xf9, 0x59, +0x7b, 0x12, 0x08, 0x99, 0xe8, 0xec, 0x88, 0x5f, 0x9b, 0xbc, 0x6f, 0x1a, +0x34, 0xfe, 0x3b, 0x5e, 0xf4, 0x3e, 0x14, 0x79, 0x1e, 0x67, 0x3d, 0xe9, +0x13, 0xad, 0xb5, 0x0f, 0x9d, 0xe5, 0x92, 0xbf, 0x83, 0x30, 0x7c, 0xe4, +0x96, 0x53, 0x24, 0x54, 0x10, 0x8c, 0x87, 0xd0, 0xb2, 0xfb, 0x76, 0x3b, +0xe2, 0x85, 0xa9, 0x2b, 0xdd, 0xcb, 0x84, 0x27, 0x5c, 0xb6, 0x4f, 0x1c, +0x46, 0xf7, 0xb4, 0x62, 0x08, 0xc3, 0x05, 0x81, 0xd8, 0x9a, 0xb7, 0x93, +0x9f, 0xbb, 0x8b, 0xd9, 0x98, 0xd2, 0x74, 0xef, 0xd9, 0x42, 0x17, 0x7b, +0x20, 0x5b, 0xef, 0xa0, 0x13, 0x41, 0xf8, 0xb0, 0x33, 0x39, 0x2a, 0xac, +0x9a, 0x88, 0xeb, 0x61, 0xc1, 0x40, 0x20, 0x9e, 0x3f, 0x1b, 0x79, 0xd7, +0x2d, 0x8b, 0x43, 0x8c, 0xcf, 0x2d, 0x5f, 0x43, 0x13, 0xd0, 0x11, 0x3d, +0x67, 0x7a, 0x1f, 0x95, 0x5c, 0xf4, 0xce, 0x26, 0x7b, 0x3a, 0x09, 0x15, +0x25, 0xf5, 0xba, 0x34, 0xf6, 0xda, 0x43, 0x68, 0x06, 0x81, 0xd8, 0xce, +0x37, 0xb4, 0x7c, 0x31, 0x94, 0x86, 0x0e, 0xaf, 0x7e, 0x76, 0xbd, 0x7f, +0x3d, 0x81, 0xc7, 0xcc, 0xf5, 0x9e, 0xb5, 0x88, 0x85, 0x75, 0xc3, 0xb4, +0xb4, 0xcc, 0x9a, 0xfb, 0x7b, 0x16, 0xe1, 0xee, 0xc6, 0x69, 0x5a, 0x35, +0x9d, 0xdd, 0x5d, 0xa9, 0xab, 0xdd, 0xc3, 0xc2, 0xaa, 0x31, 0x65, 0x44, +0x61, 0x5d, 0x1c, 0x5a, 0x7b, 0xc7, 0x9a, 0x3c, 0x96, 0x77, 0x1a, 0xc3, +0x7b, 0x50, 0xcf, 0x21, 0xc1, 0x67, 0xc5, 0x83, 0x80, 0x6a, 0x59, 0x62, +0x2c, 0x20, 0x3d, 0x2c, 0xac, 0xf2, 0xb3, 0x70, 0xf9, 0xd1, 0xe7, 0x32, +0xe6, 0xd6, 0xc4, 0x41, 0x85, 0x61, 0x6f, 0x99, 0x69, 0x61, 0x71, 0x40, +0x20, 0xa0, 0xde, 0x1c, 0x4d, 0xac, 0x45, 0xa4, 0x87, 0x85, 0x15, 0x81, +0x68, 0xdb, 0x73, 0xd0, 0xf7, 0xa7, 0xf9, 0x81, 0x58, 0xb9, 0x92, 0x0c, +0x61, 0x54, 0x42, 0x4c, 0xd0, 0x47, 0x48, 0xc9, 0x6d, 0x9c, 0x85, 0xe8, +0xa1, 0xec, 0x11, 0x81, 0xf8, 0x5c, 0xd3, 0x5f, 0x7b, 0xce, 0x41, 0xc6, +0x9f, 0xbc, 0x37, 0x4d, 0xa0, 0xcb, 0x7f, 0xc7, 0x1a, 0xdb, 0x9a, 0x98, +0xcf, 0x90, 0x7b, 0x99, 0x58, 0x92, 0xa0, 0x8b, 0x90, 0x92, 0xeb, 0xb8, +0x92, 0x69, 0xf4, 0xfa, 0x7e, 0xcd, 0x27, 0xb5, 0xe0, 0x35, 0x68, 0x35, +0x91, 0x7e, 0xde, 0xd8, 0x21, 0xce, 0x98, 0x65, 0xac, 0x3b, 0x8c, 0x52, +0x54, 0x28, 0x2f, 0x0c, 0xa9, 0xce, 0x86, 0xe8, 0x44, 0x6d, 0x3d, 0x51, +0xad, 0x71, 0xeb, 0x11, 0xc5, 0x21, 0xe5, 0x62, 0x1b, 0x5b, 0x18, 0xec, +0xe2, 0xbd, 0xd6, 0xdb, 0x28, 0xd6, 0xb3, 0x88, 0x19, 0xa6, 0x72, 0xcf, +0x4b, 0x6f, 0x01, 0x8a, 0x91, 0xfc, 0x5e, 0xed, 0x5e, 0x04, 0x62, 0x54, +0x0f, 0xc2, 0x7a, 0x0e, 0xb5, 0x8a, 0x83, 0x6d, 0x80, 0x77, 0xa6, 0x9d, +0xc5, 0x91, 0x90, 0x92, 0x58, 0xc6, 0xd0, 0x1a, 0x09, 0x6a, 0xe8, 0x53, +0x18, 0xc2, 0x05, 0xa6, 0xf5, 0xdd, 0xb7, 0xfe, 0x1c, 0xa3, 0x9c, 0x12, +0xb6, 0x61, 0x9a, 0x4c, 0xa1, 0x94, 0x4b, 0x9f, 0x31, 0xa5, 0x30, 0xd8, +0xef, 0x91, 0xf9, 0x67, 0x24, 0xff, 0x00, 0xd9, 0xb8, 0xe5, 0x14, 0x06, +0x17, 0x54, 0xbc, 0xb4, 0xbe, 0xfb, 0x1e, 0x49, 0x20, 0x6c, 0x02, 0x36, +0xf3, 0x8e, 0xf9, 0xd0, 0x99, 0x14, 0x9b, 0x7c, 0x4e, 0xf5, 0x7d, 0x4a, +0x09, 0xa4, 0x9f, 0xa7, 0x00, 0x59, 0x98, 0x4a, 0x35, 0x29, 0xd4, 0x4a, +0xa6, 0xd6, 0x4f, 0x54, 0xeb, 0x2e, 0x72, 0x04, 0x81, 0xb0, 0x9e, 0x43, +0x4d, 0x3f, 0x6f, 0xd8, 0x00, 0x2f, 0x65, 0xc8, 0x4b, 0xbf, 0x4f, 0xa9, +0xb0, 0xda, 0xe8, 0x6d, 0xb7, 0x21, 0x63, 0x38, 0xa9, 0xf4, 0xc4, 0xce, +0x54, 0x0e, 0x88, 0x40, 0x44, 0x0e, 0xa7, 0xd4, 0xf2, 0xb3, 0xda, 0xe4, +0x73, 0xea, 0x04, 0x71, 0x8a, 0x83, 0x74, 0xe4, 0x20, 0xa0, 0x4a, 0xaf, +0x61, 0xeb, 0xb6, 0xb7, 0x52, 0x8b, 0x6b, 0xcb, 0x89, 0xea, 0x9e, 0x1a, +0x0f, 0xee, 0x59, 0x80, 0x6b, 0xfa, 0x5c, 0xfa, 0xec, 0x53, 0x54, 0x25, +0xad, 0x3d, 0x83, 0x9a, 0x7e, 0x7e, 0x37, 0x4e, 0x4b, 0x1f, 0xc8, 0x98, +0x6b, 0xa8, 0xea, 0x62, 0xa4, 0x1e, 0x5a, 0x6e, 0xf4, 0x2c, 0x10, 0xb6, +0x6d, 0x46, 0x0d, 0xc5, 0x04, 0x36, 0x94, 0x94, 0xda, 0x9b, 0x09, 0x6f, +0x7a, 0xab, 0x6d, 0x13, 0x13, 0xa9, 0xdd, 0x37, 0xc0, 0xbf, 0x49, 0xe8, +0x1a, 0x17, 0x30, 0xcd, 0x43, 0xb4, 0x5c, 0xc9, 0xa4, 0x02, 0xd1, 0x6b, +0x68, 0xa9, 0x96, 0x9c, 0x83, 0x6d, 0xe3, 0x91, 0x32, 0x41, 0x1e, 0x26, +0xba, 0x6b, 0xde, 0xbc, 0xf8, 0xfc, 0x21, 0xf9, 0x08, 0x38, 0x9f, 0x67, +0xa8, 0x7d, 0x67, 0xab, 0x13, 0xb1, 0xd5, 0x10, 0x4c, 0x2f, 0x3d, 0xa5, +0x5c, 0xa5, 0x3d, 0xb3, 0xc2, 0x9d, 0x7c, 0xca, 0xf8, 0xbf, 0x88, 0x90, +0xde, 0x99, 0xad, 0x77, 0xb7, 0x94, 0xbe, 0x69, 0x12, 0x91, 0x80, 0x24, +0x5e, 0x43, 0x2d, 0x79, 0x86, 0xbd, 0x79, 0x88, 0x56, 0xef, 0x0c, 0x18, +0x41, 0x20, 0x4a, 0x84, 0x57, 0xc2, 0xfc, 0x47, 0xaa, 0x67, 0xbc, 0xe3, +0xfe, 0x96, 0xa9, 0xf6, 0xf7, 0xe4, 0x3f, 0xfb, 0xc4, 0xb2, 0x07, 0x7b, +0xb8, 0xd7, 0xbe, 0xeb, 0x71, 0x1b, 0x2d, 0x0a, 0x5a, 0x5b, 0x40, 0x7b, +0x6a, 0x5b, 0xfe, 0xec, 0xe7, 0xcb, 0x2d, 0xde, 0xf6, 0xbc, 0x45, 0x0a, +0x81, 0xf2, 0x5e, 0xf5, 0xee, 0xcb, 0xbc, 0x5a, 0x98, 0x4f, 0xfe, 0x67, +0xa2, 0xc3, 0x2b, 0xb4, 0x1d, 0x52, 0x72, 0x1d, 0x9d, 0xa8, 0xee, 0xbd, +0xc4, 0xb5, 0x84, 0x40, 0x58, 0xaf, 0xe1, 0x4c, 0x72, 0x58, 0xde, 0x85, +0x35, 0x73, 0xcd, 0xaf, 0x5e, 0xea, 0xb5, 0x4b, 0x14, 0x5a, 0xf5, 0xc8, +0x09, 0x39, 0xc1, 0x1a, 0x53, 0x4b, 0x5e, 0x83, 0xeb, 0xe4, 0x44, 0x75, +0xed, 0x49, 0xcc, 0xd6, 0x04, 0xe2, 0x6c, 0x22, 0x5a, 0x84, 0xc0, 0x2f, +0xe0, 0x93, 0xfb, 0x7b, 0xab, 0x63, 0x8a, 0xdb, 0x1d, 0xa7, 0xb3, 0x57, +0x11, 0xe3, 0x4d, 0x40, 0x91, 0x70, 0x92, 0xab, 0xac, 0x74, 0xf5, 0x6c, +0x9c, 0xbb, 0xb5, 0x3c, 0x84, 0xee, 0x74, 0x7b, 0xb8, 0x57, 0xfb, 0xd5, +0xcf, 0x98, 0x6b, 0x41, 0x3c, 0xd2, 0xc6, 0xc3, 0x84, 0x89, 0x4a, 0x5c, +0xf3, 0x2b, 0xdf, 0x73, 0xae, 0x7d, 0x53, 0x46, 0x29, 0xec, 0xc0, 0x1e, +0x43, 0x0b, 0x3b, 0x99, 0xbd, 0xbb, 0x9d, 0x16, 0xaf, 0xa8, 0x6c, 0xb9, +0xfa, 0xaa, 0xc6, 0x10, 0x9a, 0xcd, 0xe7, 0x84, 0xe2, 0xa0, 0x1e, 0x82, +0x5f, 0xf0, 0xce, 0x86, 0x89, 0x92, 0xcd, 0xc5, 0x9a, 0xc5, 0x82, 0x90, +0xd3, 0x60, 0x1e, 0x43, 0x2b, 0xb1, 0xd0, 0x33, 0x02, 0xd1, 0x4a, 0xb8, +0x46, 0x17, 0xb3, 0x98, 0x37, 0x91, 0x8d, 0x2c, 0x82, 0x56, 0x1c, 0x82, +0x8a, 0xa2, 0xda, 0xc4, 0x60, 0x97, 0x67, 0x51, 0xdb, 0x1c, 0xf5, 0x63, +0x74, 0x62, 0xf9, 0xec, 0x97, 0xc7, 0x29, 0xe8, 0x5e, 0xdb, 0x39, 0xb4, +0x24, 0x10, 0xb6, 0xb4, 0x55, 0x77, 0xb6, 0x9a, 0x10, 0xdd, 0x9b, 0x3c, +0x7d, 0xf6, 0x7b, 0x35, 0xbc, 0x0f, 0x3d, 0x0f, 0x90, 0xa3, 0x78, 0xc0, +0x9e, 0x25, 0xf1, 0x0b, 0x6b, 0x2f, 0x2d, 0x24, 0xaa, 0x12, 0x0b, 0xf2, +0x12, 0xfd, 0xb2, 0xf4, 0xbc, 0x4b, 0x6d, 0x4d, 0x20, 0x82, 0xcb, 0x61, +0x16, 0x23, 0xe0, 0x9a, 0x18, 0x9d, 0x34, 0xec, 0xe0, 0xff, 0xfc, 0x61, +0x1a, 0x22, 0x91, 0xdd, 0xb1, 0xfc, 0xdb, 0xd0, 0xe4, 0x67, 0x57, 0xd3, +0x05, 0x7a, 0xed, 0xbd, 0xeb, 0xdf, 0xb7, 0x87, 0xba, 0x42, 0x93, 0xdf, +0x97, 0xaf, 0xa3, 0xcd, 0xe5, 0xd4, 0xf4, 0xb3, 0xeb, 0x82, 0xbc, 0xf6, +0x77, 0xf4, 0xef, 0xe5, 0x2a, 0xe1, 0xd5, 0xef, 0xd9, 0x79, 0xbc, 0xbc, +0xa6, 0x9c, 0xc5, 0xe2, 0xe8, 0xe3, 0xd4, 0x85, 0xc7, 0x30, 0xb7, 0x5a, +0x99, 0x74, 0x56, 0x20, 0x6a, 0x2f, 0x75, 0x55, 0xef, 0xc1, 0x8b, 0xc3, +0x7c, 0xe1, 0xdd, 0x3e, 0x15, 0x13, 0x13, 0x5e, 0x59, 0xd6, 0x4c, 0xc5, +0x26, 0x34, 0x19, 0x2f, 0x2a, 0x0e, 0xaf, 0x4c, 0x05, 0xc6, 0x9a, 0x89, +0xf3, 0x2f, 0x39, 0x0e, 0xc9, 0xa9, 0x30, 0x76, 0xe6, 0x39, 0xec, 0xc9, +0x59, 0x2c, 0x25, 0xe7, 0xb6, 0x7f, 0xde, 0xe4, 0x25, 0x10, 0x06, 0x04, +0x22, 0xb6, 0xf7, 0xe0, 0x77, 0xd4, 0x73, 0xe5, 0x63, 0x68, 0xaf, 0x6d, +0x7e, 0x8d, 0xd4, 0x25, 0xae, 0x7a, 0x52, 0x7a, 0xf0, 0x4a, 0x9b, 0x49, +0x05, 0x9f, 0x90, 0x13, 0x3c, 0x1b, 0x24, 0x73, 0x2f, 0x55, 0x49, 0x57, +0x04, 0xa2, 0xe6, 0xaa, 0x20, 0xdd, 0x79, 0x0f, 0xb2, 0xa0, 0x4d, 0x1a, +0x6a, 0x4a, 0xf9, 0x3c, 0xbd, 0xf8, 0x10, 0xee, 0xf0, 0xcf, 0xbc, 0x84, +0x50, 0xe0, 0x4d, 0x54, 0x4e, 0x6f, 0x55, 0x49, 0x57, 0x04, 0xa2, 0xd6, +0x53, 0xc9, 0xda, 0xfa, 0x61, 0xa0, 0xdd, 0xee, 0x92, 0x52, 0xb0, 0x35, +0x77, 0xe2, 0xa8, 0xac, 0xa9, 0x22, 0x04, 0x85, 0x37, 0x81, 0x40, 0x34, +0x71, 0x50, 0xae, 0xb6, 0xab, 0x2c, 0x75, 0xf2, 0x98, 0x96, 0x0f, 0x43, +0xec, 0x76, 0x65, 0x71, 0x4a, 0x15, 0xf2, 0xd3, 0x24, 0x3a, 0x0b, 0xd2, +0xeb, 0x50, 0x61, 0xee, 0xa8, 0x02, 0x67, 0x26, 0x2a, 0x9d, 0x8c, 0x23, +0x0b, 0x44, 0xd8, 0x5e, 0xa1, 0xb6, 0xcf, 0xa7, 0xd5, 0x3e, 0x03, 0xed, +0x76, 0x6f, 0xa9, 0x12, 0xd4, 0xe4, 0x1d, 0xce, 0xbd, 0x0f, 0x97, 0xbf, +0x92, 0x91, 0x4a, 0xa7, 0x5a, 0x5c, 0xf9, 0x91, 0xc5, 0xc1, 0x05, 0xcd, +0xd9, 0x6a, 0x4b, 0x52, 0x6b, 0x09, 0xa6, 0x1b, 0xeb, 0x0e, 0xe0, 0x29, +0x55, 0x82, 0xda, 0xf4, 0x4c, 0x82, 0x73, 0x42, 0x91, 0xad, 0x80, 0x85, +0x16, 0xe2, 0x15, 0xbc, 0xf0, 0x11, 0x93, 0xd2, 0x6e, 0xa3, 0x9d, 0x43, +0x6d, 0xe7, 0x20, 0xf4, 0x56, 0xb1, 0x01, 0x17, 0xb4, 0x39, 0x55, 0x8b, +0x0d, 0xee, 0x52, 0x8e, 0xf7, 0x8e, 0x32, 0xae, 0x1d, 0x78, 0x13, 0x78, +0x0f, 0x65, 0x6a, 0xb1, 0xc5, 0x6a, 0x14, 0x08, 0xf5, 0x6a, 0xfc, 0x2e, +0x6a, 0xb4, 0xc9, 0xb1, 0x24, 0x6c, 0xb1, 0xc1, 0x8e, 0xb4, 0xc1, 0xd0, +0x13, 0xde, 0x44, 0x01, 0x46, 0xce, 0x3d, 0xf8, 0x9f, 0xfd, 0x91, 0xa0, +0xb7, 0x17, 0xc3, 0x94, 0xee, 0x8c, 0x2a, 0xa1, 0x95, 0xe0, 0xa4, 0xf4, +0x70, 0x09, 0x3b, 0x79, 0x27, 0x89, 0xc4, 0x7a, 0x61, 0xd6, 0x27, 0x13, +0x8a, 0x2c, 0xed, 0xfe, 0x29, 0x89, 0xcd, 0xe8, 0x22, 0x8e, 0xec, 0x39, +0xf8, 0x41, 0x7d, 0xab, 0x29, 0x41, 0x6d, 0x2f, 0x2e, 0x1a, 0xb8, 0x9a, +0xe3, 0x66, 0x1b, 0x11, 0xc6, 0xde, 0x10, 0x40, 0x72, 0x92, 0x0b, 0x85, +0x69, 0xb3, 0x4e, 0xd8, 0x29, 0x15, 0x03, 0xe7, 0x1e, 0x6c, 0x69, 0xe3, +0x64, 0x13, 0xd4, 0xa5, 0xc2, 0x4b, 0xf2, 0x2e, 0xec, 0xb5, 0xa7, 0x83, +0xb5, 0x7d, 0xf8, 0xb4, 0x71, 0xd1, 0x77, 0x12, 0x79, 0x41, 0x61, 0xd7, +0x99, 0xf9, 0x3d, 0xa6, 0x5e, 0x63, 0x10, 0x0a, 0xbc, 0x87, 0xa4, 0xed, +0x86, 0xc3, 0xfc, 0x43, 0x09, 0xd1, 0xb4, 0x77, 0x1f, 0xfb, 0x1d, 0xf3, +0xe8, 0x03, 0x3e, 0x45, 0xfe, 0x81, 0xf3, 0x0e, 0xe5, 0x42, 0x4f, 0xc9, +0xf3, 0x9c, 0xde, 0x63, 0xe1, 0x1d, 0x47, 0xe2, 0x3e, 0x9a, 0xf7, 0xb0, +0x11, 0xb7, 0xbc, 0xd9, 0x03, 0x72, 0x25, 0xbc, 0x07, 0x15, 0x07, 0xe3, +0x35, 0x4c, 0xa3, 0x0f, 0xce, 0xd8, 0xf9, 0x07, 0x4a, 0x5a, 0xeb, 0x08, +0x3b, 0xe5, 0x38, 0x8c, 0x8b, 0x50, 0x44, 0xa0, 0xd7, 0xc4, 0x74, 0x78, +0x51, 0x7c, 0x70, 0xf3, 0xd7, 0xea, 0x4e, 0xd5, 0x86, 0x97, 0x72, 0x27, +0xa7, 0xad, 0x38, 0xe0, 0x35, 0xfc, 0x15, 0x6d, 0x4d, 0xd2, 0x3b, 0x4a, +0x5a, 0x11, 0x0a, 0x12, 0xd9, 0xf9, 0xdd, 0xf7, 0x52, 0x8b, 0xb6, 0xb9, +0xa1, 0x2b, 0xb6, 0xa9, 0x08, 0xe8, 0xbd, 0xc0, 0x7b, 0x16, 0x84, 0x0f, +0xde, 0x43, 0xee, 0xc3, 0x71, 0xf6, 0xc2, 0x1f, 0x76, 0xb8, 0x1f, 0x17, +0x10, 0xbd, 0x1f, 0xc2, 0x51, 0xb5, 0xd4, 0x33, 0x39, 0xf3, 0x13, 0xb0, +0x37, 0xb4, 0x94, 0x43, 0x10, 0xb4, 0x97, 0xbf, 0xfb, 0x7b, 0x4d, 0xe3, +0xde, 0x45, 0x3b, 0xab, 0x50, 0xda, 0xdc, 0x43, 0x4e, 0xef, 0x41, 0x2b, +0x74, 0xcc, 0x01, 0x38, 0x76, 0xb8, 0x66, 0xe1, 0xd0, 0x8e, 0xb5, 0x91, +0x16, 0x08, 0xa8, 0x78, 0x3d, 0xca, 0x18, 0x76, 0x5a, 0xf0, 0x28, 0x0a, +0x85, 0x96, 0x82, 0x70, 0xce, 0xad, 0x95, 0x67, 0x51, 0x22, 0xf7, 0x60, +0x4b, 0x6a, 0x47, 0x3d, 0xe3, 0xb0, 0x47, 0xb8, 0x23, 0xed, 0x2e, 0x27, +0x1e, 0x67, 0x1b, 0x9b, 0x82, 0x8c, 0x61, 0x6f, 0x8d, 0x38, 0x40, 0xea, +0xd0, 0x92, 0x71, 0xe1, 0x5a, 0x5b, 0xe4, 0xde, 0xcb, 0x28, 0x4b, 0x89, +0x43, 0x03, 0x17, 0xfe, 0x14, 0x41, 0xab, 0xca, 0x1c, 0x89, 0x69, 0x84, +0x22, 0x4f, 0x32, 0x9b, 0x0d, 0x5a, 0x6c, 0x71, 0x68, 0xbd, 0xf6, 0xd8, +0x7a, 0x0f, 0xb9, 0xaa, 0xb9, 0xb4, 0x5d, 0x37, 0xa1, 0xa5, 0xe7, 0x21, +0x87, 0x18, 0xe1, 0x25, 0xce, 0x3c, 0x34, 0x4d, 0xd6, 0xae, 0xb1, 0x0d, +0x6f, 0x72, 0xeb, 0x14, 0x87, 0x0e, 0x4e, 0xf7, 0x16, 0xf1, 0x1e, 0x6c, +0x42, 0x9c, 0xd0, 0xd2, 0xf3, 0x77, 0x73, 0x35, 0x1f, 0x84, 0xf7, 0xd0, +0x87, 0x50, 0xe4, 0xbc, 0xa3, 0x66, 0x54, 0xa1, 0x98, 0x13, 0x3c, 0xc4, +0xa6, 0x77, 0xbd, 0xd6, 0x7b, 0x28, 0x51, 0xd6, 0x2a, 0xe1, 0x13, 0x7f, +0x18, 0x0e, 0x81, 0x58, 0xd9, 0xcc, 0x5c, 0x6d, 0xad, 0x81, 0xf7, 0xd0, +0x1d, 0x13, 0xb7, 0xda, 0x25, 0x52, 0xe0, 0x98, 0x6e, 0x5a, 0x27, 0x7d, +0x81, 0x6e, 0xb6, 0x82, 0xc8, 0x15, 0x3a, 0xaf, 0x21, 0x42, 0x31, 0x68, +0x87, 0xd6, 0xa7, 0xc8, 0xbb, 0x89, 0xd0, 0x7b, 0x89, 0xbc, 0x0e, 0x9b, +0x5d, 0x72, 0x58, 0x3b, 0x88, 0x56, 0xd2, 0xda, 0xd3, 0x61, 0xa3, 0x12, +0xf9, 0x07, 0x77, 0xa0, 0xf5, 0xc7, 0xc8, 0x3b, 0x45, 0x73, 0x47, 0x34, +0x93, 0x1a, 0x56, 0xc7, 0x48, 0x81, 0x1b, 0xed, 0x50, 0xdc, 0xc1, 0x76, +0x65, 0x8b, 0x6d, 0x8a, 0xe7, 0x5c, 0x35, 0x6d, 0x40, 0x46, 0xf7, 0x26, +0x96, 0x2b, 0xe2, 0x80, 0x47, 0x36, 0x0c, 0xb7, 0xcc, 0x9d, 0x20, 0xba, +0x15, 0x89, 0x85, 0x07, 0xb4, 0x3e, 0xc0, 0x6c, 0x73, 0x3c, 0x44, 0xa2, +0x0e, 0xe4, 0xe7, 0xbf, 0x18, 0x5e, 0xc2, 0x13, 0x1b, 0x2c, 0xe4, 0x94, +0xd1, 0x9b, 0xe8, 0x32, 0xa7, 0xb5, 0x38, 0xe2, 0x70, 0x9b, 0xae, 0xaa, +0xec, 0x42, 0xf4, 0x3a, 0x4f, 0xf9, 0xb5, 0x86, 0xe6, 0x85, 0x23, 0x25, +0xc8, 0x42, 0xae, 0xe4, 0x1f, 0x08, 0x2d, 0x8d, 0xeb, 0x4d, 0x64, 0xec, +0xeb, 0x84, 0x40, 0xb8, 0xf1, 0xaa, 0x41, 0x26, 0x0d, 0x6d, 0xc8, 0xe2, +0x54, 0x4b, 0x87, 0xdb, 0x01, 0x1b, 0x8d, 0x4d, 0x67, 0xc3, 0x4b, 0x34, +0xe3, 0x03, 0x97, 0x38, 0x81, 0xdd, 0x6b, 0xcb, 0x96, 0xab, 0x1e, 0xc4, +0x48, 0x3b, 0xd9, 0x9b, 0x8a, 0x45, 0x2d, 0x9d, 0x6e, 0x07, 0x6b, 0x34, +0x76, 0x25, 0xff, 0x40, 0xd5, 0x12, 0x3c, 0x36, 0x19, 0xa9, 0x36, 0x78, +0x08, 0x04, 0x2e, 0xfb, 0xaa, 0x67, 0x51, 0x83, 0x58, 0x8c, 0x70, 0x51, +0xbb, 0x8c, 0xb7, 0x33, 0x02, 0xc1, 0x15, 0xa2, 0x10, 0x90, 0xa4, 0xf9, +0x1f, 0x02, 0x41, 0xc2, 0xef, 0xe9, 0xa0, 0x73, 0x79, 0x9b, 0x89, 0x8d, +0x16, 0x76, 0xba, 0x5d, 0x28, 0x6f, 0xe5, 0x40, 0x1c, 0xac, 0x45, 0x03, +0x96, 0x04, 0x67, 0xc0, 0x10, 0x08, 0x76, 0x65, 0xfb, 0x3c, 0x8b, 0x52, +0xb9, 0x8a, 0x4e, 0xef, 0xdf, 0x9d, 0xf1, 0x1e, 0xa0, 0x72, 0xa1, 0xe8, +0x2f, 0x8c, 0x79, 0x61, 0xc7, 0xcb, 0x05, 0x1b, 0x3b, 0x07, 0x5f, 0x29, +0xaf, 0xa2, 0xa7, 0x6b, 0x15, 0x2f, 0x84, 0x04, 0xc8, 0x3d, 0xc0, 0xee, +0xb9, 0xea, 0x38, 0x24, 0x1c, 0x47, 0x20, 0xc8, 0x3f, 0x1c, 0xdf, 0x01, +0xe7, 0x6c, 0x2a, 0xd6, 0x5b, 0xd8, 0xe9, 0xcc, 0x38, 0xc5, 0x7b, 0x80, +0x13, 0x3c, 0xf2, 0x13, 0x47, 0x3c, 0x8a, 0xae, 0xcb, 0xce, 0xf1, 0x20, +0xc6, 0x08, 0x3f, 0xb5, 0x5e, 0xed, 0x74, 0x72, 0x9c, 0xe2, 0x3d, 0xc0, +0x69, 0xa1, 0xd8, 0xf2, 0xfe, 0xed, 0xdc, 0xf5, 0x9b, 0xaf, 0xa9, 0xe7, +0x07, 0x71, 0xca, 0xad, 0xc2, 0x83, 0x68, 0x33, 0xfc, 0xd4, 0xa8, 0x37, +0x71, 0x73, 0x9c, 0x6c, 0x85, 0xc2, 0xde, 0xbf, 0x9a, 0xe4, 0xc2, 0x46, +0x3a, 0x83, 0x74, 0xea, 0xf0, 0x08, 0x07, 0x8f, 0xe2, 0x7a, 0x15, 0x05, +0xf2, 0x14, 0x4b, 0x43, 0x3b, 0x9f, 0xc3, 0x1d, 0x87, 0x19, 0x9f, 0x90, +0xc8, 0xfb, 0xbf, 0x8f, 0xf8, 0x43, 0x93, 0xb5, 0xaf, 0x44, 0xac, 0x73, +0x87, 0x9e, 0x1a, 0xd9, 0x09, 0xdd, 0x1d, 0x1e, 0x2e, 0x40, 0x5b, 0x02, +0xc1, 0x24, 0x4c, 0x16, 0x4e, 0xc9, 0x9a, 0xa3, 0x68, 0xa0, 0x5d, 0xca, +0x19, 0x2f, 0x97, 0xcd, 0x0b, 0x40, 0x89, 0xdd, 0x19, 0x13, 0x31, 0x8f, +0x50, 0x14, 0xb8, 0x4a, 0xb1, 0xd6, 0x90, 0xcc, 0x99, 0x4d, 0xcc, 0xc4, +0x10, 0x02, 0x88, 0xb0, 0x10, 0x5d, 0xdd, 0xad, 0x76, 0x72, 0x8b, 0x5c, +0xb5, 0x1e, 0x5e, 0xae, 0xfc, 0x44, 0xc5, 0x65, 0xa1, 0x67, 0x04, 0x82, +0x8d, 0x0b, 0x40, 0x0d, 0x02, 0xe1, 0xb8, 0xf5, 0x2c, 0x39, 0x19, 0xbd, +0x89, 0x1a, 0xdf, 0xe1, 0xc4, 0x78, 0x04, 0x28, 0x44, 0xac, 0x1d, 0x2a, +0x17, 0xc1, 0x27, 0x27, 0x6a, 0x93, 0xb1, 0xb5, 0xd6, 0x15, 0x95, 0x7a, +0x11, 0x93, 0x63, 0xd3, 0x02, 0x50, 0x8c, 0x58, 0xb7, 0xca, 0x91, 0xb8, +0x6e, 0xe8, 0x7d, 0x89, 0x40, 0x84, 0x22, 0x51, 0x69, 0x2e, 0x62, 0x72, +0xe4, 0xc9, 0x00, 0x8a, 0x11, 0xed, 0x22, 0x0d, 0xea, 0xcf, 0xf3, 0x79, +0x13, 0x57, 0x3d, 0x3f, 0x79, 0x57, 0x7a, 0x3b, 0x5b, 0x10, 0x66, 0xac, +0x6d, 0x41, 0x9d, 0x5c, 0x9c, 0x73, 0x1f, 0x00, 0x50, 0xd2, 0x83, 0x70, +0x9c, 0x60, 0xcd, 0x89, 0x08, 0xf1, 0xa5, 0xb3, 0x13, 0x72, 0x8d, 0xaa, +0x7a, 0x12, 0xc6, 0x9b, 0xa8, 0x6d, 0x31, 0x8d, 0x21, 0x10, 0xc3, 0xdf, +0xe7, 0x0d, 0x70, 0x7a, 0x37, 0x1a, 0xb9, 0xee, 0x7e, 0xe2, 0x91, 0xe6, +0x7d, 0x7f, 0x67, 0x73, 0x13, 0x22, 0x10, 0x2a, 0x12, 0xe6, 0xae, 0xe7, +0xda, 0xde, 0xdf, 0xe4, 0xe2, 0x56, 0x6a, 0x21, 0x12, 0x00, 0x67, 0x76, +0xa3, 0x47, 0x3b, 0x19, 0x22, 0x10, 0x55, 0x71, 0xf8, 0xc2, 0x22, 0x2b, +0x10, 0x3f, 0x7f, 0xfe, 0xec, 0x22, 0x49, 0xbd, 0xe3, 0xde, 0x08, 0xc2, +0x4d, 0x00, 0x57, 0xc5, 0x42, 0x26, 0x92, 0x08, 0x86, 0x2c, 0x1a, 0x7b, +0x45, 0x83, 0x1d, 0x5a, 0x1d, 0x42, 0xb1, 0xd7, 0xa3, 0x10, 0x71, 0xd0, +0x9b, 0xda, 0xe4, 0xbf, 0x5d, 0x9d, 0x09, 0xdd, 0xc3, 0x1e, 0x84, 0xfc, +0x4c, 0x5b, 0x63, 0x96, 0x31, 0x0a, 0x90, 0x46, 0x34, 0x26, 0x63, 0xb3, +0xdf, 0x89, 0x59, 0x9b, 0x99, 0x78, 0x75, 0x2d, 0xac, 0xcf, 0x3c, 0x42, +0x59, 0x44, 0xc5, 0x6b, 0x70, 0x1f, 0x2b, 0x9a, 0x6a, 0x7c, 0x7f, 0x87, +0x73, 0x64, 0xf2, 0xb3, 0x79, 0xc1, 0xc3, 0xcb, 0x05, 0x00, 0x78, 0xe5, +0x11, 0xaa, 0x57, 0xa1, 0xde, 0x82, 0x86, 0x96, 0x5c, 0xfd, 0xa7, 0xe1, +0x0f, 0x0b, 0x84, 0x88, 0xe2, 0xaf, 0x5f, 0xbf, 0xde, 0x9e, 0x78, 0xbe, +0x94, 0xbe, 0x02, 0x00, 0xac, 0x79, 0x15, 0x6a, 0x7e, 0xa1, 0xbc, 0x57, +0xee, 0xf9, 0x9d, 0x16, 0x88, 0x27, 0xf9, 0x08, 0xf2, 0x10, 0x00, 0x00, +0x3d, 0x88, 0xda, 0x19, 0x81, 0xf8, 0xfd, 0xfb, 0xf7, 0x33, 0x81, 0x98, +0x78, 0xac, 0x00, 0x00, 0x7d, 0x70, 0xa8, 0x05, 0xba, 0xe4, 0x20, 0x9e, +0x78, 0x10, 0x78, 0x0f, 0x00, 0x00, 0x9d, 0x71, 0xdb, 0x5b, 0x55, 0x47, +0x68, 0x09, 0x00, 0x60, 0x60, 0xb1, 0x70, 0xff, 0xe6, 0x4e, 0x26, 0xe7, +0xef, 0xf6, 0xb6, 0xa2, 0x21, 0xff, 0x2d, 0x26, 0xbf, 0xaf, 0xe6, 0x08, +0x2b, 0x01, 0x00, 0x20, 0x1a, 0xae, 0xfe, 0xc4, 0x3b, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0xc0, 0x65, 0xee, 0x7f, 0x6c, 0xe2, 0x31, 0x00, 0x00, 0xc0, 0x07, +0xbe, 0x7c, 0xf9, 0xf2, 0x5f, 0x31, 0x9e, 0x04, 0x00, 0x00, 0x58, 0x96, +0x3f, 0xf6, 0xf6, 0xf5, 0xeb, 0xd7, 0xff, 0xf0, 0x28, 0x00, 0x00, 0x40, +0x99, 0x44, 0x1c, 0xbc, 0x2d, 0x3c, 0x0e, 0x00, 0x00, 0x10, 0x66, 0x23, +0x0e, 0x08, 0x04, 0x00, 0x00, 0x3c, 0x58, 0x02, 0x71, 0x78, 0xf3, 0x82, +0x01, 0x00, 0x00, 0x83, 0x72, 0xf7, 0xc9, 0xe8, 0x37, 0x04, 0x02, 0x00, +0x00, 0x94, 0xf9, 0xdb, 0xb7, 0x6f, 0xff, 0xdb, 0x10, 0x07, 0xb1, 0x3b, +0x8f, 0x08, 0x00, 0x60, 0x30, 0xaf, 0xc1, 0x57, 0x28, 0x6d, 0x09, 0xc3, +0x1b, 0x25, 0xae, 0x00, 0x00, 0xe3, 0x31, 0xbd, 0xf0, 0x1a, 0x1e, 0x46, +0x89, 0x2b, 0x00, 0xc0, 0x58, 0xcc, 0xaf, 0x84, 0xc1, 0x51, 0xc1, 0x04, +0x00, 0x30, 0x96, 0xd7, 0xf0, 0x24, 0x11, 0xbd, 0x65, 0x24, 0xa8, 0x01, +0x00, 0x7a, 0xf6, 0x18, 0x4e, 0x08, 0x03, 0x09, 0x6a, 0x00, 0x80, 0xce, +0x59, 0x4e, 0x0a, 0x03, 0x09, 0x6a, 0x00, 0x80, 0x0e, 0xb9, 0x89, 0x30, +0x5c, 0xf0, 0x1a, 0x48, 0x50, 0x03, 0x00, 0xf4, 0x28, 0x0c, 0x7b, 0xaa, +0x93, 0x1c, 0xf9, 0x07, 0x00, 0x80, 0x61, 0x78, 0x24, 0xa0, 0xbf, 0x7f, +0xff, 0xfe, 0x4f, 0x0c, 0x81, 0xf0, 0x5f, 0xe3, 0xc6, 0x63, 0x05, 0x00, +0x68, 0x9b, 0xe5, 0xc7, 0x8f, 0x1f, 0xff, 0x2c, 0xcb, 0xf2, 0x26, 0x02, +0x11, 0xc9, 0x7b, 0x48, 0x55, 0xde, 0x8a, 0xe8, 0x00, 0x00, 0xe4, 0xf0, +0x1a, 0x24, 0x4f, 0xf0, 0xf3, 0xe7, 0xcf, 0x37, 0xb1, 0x58, 0xe2, 0xe0, +0xbd, 0x87, 0x14, 0xd5, 0x4b, 0xf2, 0x35, 0x09, 0x5b, 0x01, 0x00, 0x24, +0xe4, 0x91, 0x6b, 0x10, 0x41, 0xf8, 0xf5, 0xeb, 0xd7, 0x43, 0x1c, 0x22, +0x79, 0x0d, 0xb1, 0x72, 0x0f, 0x37, 0xf7, 0xf7, 0xaa, 0xd2, 0xc9, 0x7f, +0x3d, 0x4d, 0x9a, 0xe3, 0x41, 0x00, 0x00, 0xa4, 0x12, 0x07, 0xf1, 0x1a, +0x24, 0xa4, 0xf4, 0xfb, 0xf7, 0xef, 0xe8, 0xe2, 0x20, 0x5f, 0x57, 0xcc, +0xed, 0xbb, 0x87, 0xfa, 0xe6, 0xff, 0xde, 0xa2, 0x02, 0x20, 0xf6, 0x24, +0x07, 0xc2, 0xa9, 0x6c, 0x00, 0x80, 0x54, 0x88, 0x38, 0x48, 0xae, 0x21, +0x85, 0x38, 0xa8, 0x47, 0x22, 0x5f, 0xdb, 0x8b, 0xc4, 0x9a, 0x27, 0xf1, +0xf0, 0x08, 0xe4, 0x73, 0x9c, 0x48, 0x86, 0x73, 0xe8, 0x0e, 0x00, 0x20, +0x87, 0x38, 0x44, 0x2c, 0x67, 0xfd, 0x24, 0x10, 0x81, 0x48, 0xdc, 0xdd, +0xc5, 0x73, 0x15, 0x1c, 0xba, 0x03, 0x00, 0x48, 0xc3, 0xcd, 0x8a, 0x83, +0x2c, 0xe2, 0x2e, 0x6e, 0xce, 0xe1, 0x53, 0x98, 0x49, 0x04, 0x48, 0x45, +0xe2, 0xaa, 0x10, 0xf9, 0x7f, 0x3f, 0xf1, 0x1a, 0x01, 0x00, 0xe2, 0xf2, +0xb8, 0xe9, 0xcd, 0x8a, 0x43, 0x6c, 0xcf, 0x61, 0xcb, 0xf4, 0x7b, 0xca, +0xaf, 0xae, 0xce, 0x92, 0x59, 0x00, 0x80, 0x71, 0xc5, 0x41, 0xc4, 0x40, +0x77, 0xf3, 0x39, 0xc5, 0x21, 0x14, 0x89, 0x8b, 0x25, 0xb4, 0xe4, 0x1e, +0x00, 0x00, 0x62, 0x7b, 0x0e, 0x56, 0x1c, 0x22, 0x1e, 0x82, 0x3b, 0x64, +0xf2, 0x19, 0x2e, 0x84, 0xb5, 0xf0, 0x1e, 0x00, 0x00, 0x22, 0x32, 0xdb, +0x84, 0x71, 0x49, 0x71, 0x50, 0x3b, 0x73, 0xde, 0x82, 0xc4, 0x34, 0x00, +0x40, 0x5c, 0x1e, 0x6d, 0x33, 0x54, 0x1c, 0x52, 0x54, 0x2b, 0xb9, 0x93, +0x15, 0x4e, 0x47, 0x42, 0x4d, 0x09, 0x4f, 0x63, 0x03, 0x00, 0x0c, 0xc7, +0x87, 0x4a, 0x25, 0x4d, 0x0e, 0xd7, 0x20, 0x0e, 0xce, 0xe4, 0x23, 0xf6, +0x84, 0x9a, 0xa8, 0x5a, 0x02, 0x00, 0x88, 0xc3, 0xfb, 0x19, 0x83, 0x50, +0x1c, 0x6a, 0x11, 0x06, 0xbb, 0xf0, 0xbf, 0xf2, 0x68, 0x10, 0x07, 0x00, +0xe8, 0x7d, 0xc1, 0x9e, 0x8d, 0x4d, 0xe6, 0xd7, 0x7b, 0xc4, 0xef, 0xb1, +0xe8, 0x69, 0xe4, 0x30, 0xa4, 0xe4, 0x0f, 0xa8, 0xbd, 0xd5, 0x68, 0xa6, +0x15, 0x07, 0x77, 0x48, 0x00, 0xc0, 0x18, 0x3b, 0x78, 0x59, 0xac, 0xd7, +0x4e, 0x0a, 0x4b, 0xcc, 0x5d, 0x5b, 0x69, 0x8b, 0xc9, 0x7f, 0xcb, 0xdf, +0xf5, 0xb7, 0xad, 0xcd, 0x3b, 0x44, 0x43, 0xfb, 0x15, 0xcd, 0xfa, 0x3d, +0x44, 0x14, 0xe4, 0xeb, 0xea, 0xd7, 0xd4, 0xaf, 0x5b, 0x53, 0x38, 0xe9, +0x99, 0x87, 0xb0, 0xe6, 0xdd, 0xe0, 0x39, 0x00, 0x40, 0x57, 0x5e, 0xc2, +0x8b, 0xc6, 0x72, 0x9f, 0x84, 0x42, 0x63, 0xf0, 0xba, 0xd3, 0xd7, 0x85, +0x5d, 0x4c, 0xbe, 0x96, 0x17, 0x8d, 0xc5, 0x0a, 0xce, 0xda, 0xd7, 0x57, +0x81, 0x68, 0x41, 0x10, 0xb6, 0x9e, 0x45, 0xf0, 0xd9, 0x17, 0x47, 0x42, +0x1a, 0x06, 0x5f, 0x50, 0xee, 0x2b, 0xe1, 0x87, 0x59, 0x17, 0x84, 0x1d, +0x36, 0x5f, 0xb0, 0xc9, 0x7c, 0x7f, 0xda, 0x25, 0x5f, 0x10, 0x05, 0x59, +0xb8, 0xaf, 0x96, 0x8c, 0xda, 0x5c, 0x41, 0x68, 0x22, 0x20, 0x2a, 0x1c, +0xa5, 0x4b, 0x53, 0x33, 0x18, 0xc2, 0x00, 0x43, 0x2d, 0x20, 0x93, 0x5d, +0xf4, 0xb5, 0x7d, 0x71, 0x6d, 0x2e, 0xbe, 0x7e, 0x2e, 0xbb, 0x63, 0x0d, +0x84, 0x68, 0x42, 0x4c, 0x1e, 0x4c, 0xfa, 0x1e, 0x6d, 0x98, 0x28, 0xc6, +0xc2, 0x2d, 0x5f, 0x43, 0x0f, 0xb1, 0x3d, 0x33, 0x11, 0x0c, 0xf5, 0x32, +0xe4, 0xdf, 0xf4, 0x22, 0x1a, 0x5c, 0x49, 0x0a, 0xdd, 0xef, 0x26, 0xdd, +0x93, 0xd8, 0x73, 0x2f, 0x93, 0x78, 0x45, 0x48, 0x7a, 0x16, 0x90, 0x77, +0x81, 0x57, 0x51, 0xd0, 0x45, 0x3c, 0xe6, 0x8d, 0x6b, 0x2e, 0x48, 0xda, +0xbe, 0x12, 0x09, 0x35, 0x0d, 0x4b, 0x75, 0xe4, 0x59, 0x4c, 0x2c, 0x25, +0xd0, 0x8d, 0x67, 0xd0, 0xb3, 0x18, 0x9c, 0x15, 0x10, 0x93, 0x6c, 0x9d, +0x1a, 0x0b, 0x17, 0xdc, 0xd7, 0x04, 0x41, 0x16, 0x60, 0xbb, 0xb3, 0xd7, +0x1d, 0xbc, 0x4b, 0x1c, 0x93, 0x5f, 0xf3, 0x26, 0x7a, 0x08, 0x37, 0xbd, +0xf8, 0xdc, 0x54, 0x2c, 0x41, 0x33, 0xe8, 0x35, 0x87, 0x77, 0x1b, 0x5a, +0x40, 0x08, 0x2e, 0x89, 0x46, 0x69, 0x2f, 0xe3, 0xb6, 0x26, 0xf0, 0x62, +0x5a, 0x5d, 0xa4, 0x7d, 0x82, 0xb6, 0x42, 0x3b, 0x39, 0x13, 0xc1, 0x36, +0x37, 0x51, 0x73, 0xa9, 0xea, 0x8e, 0xd0, 0xd1, 0x07, 0xe1, 0x73, 0xf4, +0x59, 0x82, 0xcc, 0x3b, 0x3f, 0x7b, 0x5f, 0xad, 0xee, 0x02, 0x9f, 0xd9, +0x66, 0xf2, 0xf7, 0x59, 0xb5, 0x08, 0x76, 0xdd, 0x74, 0x41, 0x0e, 0x6d, +0x23, 0xff, 0x71, 0x26, 0x29, 0xff, 0xe1, 0xdf, 0xd9, 0xef, 0xa1, 0x31, +0x7b, 0xeb, 0x19, 0xac, 0x89, 0xc1, 0x9a, 0x30, 0xb8, 0x7a, 0xcf, 0x09, +0x54, 0x5d, 0xbe, 0x6a, 0x3b, 0xc6, 0xea, 0x33, 0x77, 0xf4, 0x5a, 0x82, +0xc8, 0x6e, 0xff, 0x64, 0x27, 0xbf, 0xdd, 0xf9, 0xb1, 0xe8, 0xb6, 0xb7, +0x70, 0xd8, 0x30, 0x83, 0xfe, 0xbf, 0x9a, 0x2e, 0x26, 0xf6, 0xf7, 0xec, +0xc2, 0xae, 0xbb, 0xf8, 0xd0, 0x6c, 0xd2, 0x58, 0x4d, 0x05, 0xe0, 0x95, +0x08, 0xac, 0x89, 0x42, 0xaa, 0x1c, 0xc3, 0x08, 0x16, 0xde, 0x24, 0xe7, +0x4c, 0x17, 0x57, 0x04, 0x02, 0xae, 0xba, 0xfe, 0x0b, 0xb1, 0x7d, 0x6c, +0x4b, 0x5c, 0x8e, 0x9a, 0x8a, 0xcb, 0x96, 0x70, 0x58, 0x01, 0xd1, 0x53, +0xc7, 0x78, 0x8f, 0xf1, 0xc4, 0x41, 0x7b, 0x2d, 0x69, 0x73, 0xbe, 0x67, +0xbd, 0x97, 0x10, 0x08, 0x50, 0x21, 0x98, 0x09, 0xe7, 0x60, 0xb5, 0x7a, +0x35, 0xd8, 0xf9, 0x70, 0x98, 0x26, 0xd2, 0xc3, 0xdc, 0xc9, 0x9e, 0xeb, +0x4d, 0x29, 0x75, 0x1d, 0xd4, 0x23, 0xd0, 0x70, 0x10, 0x42, 0x80, 0x61, +0xfd, 0x7b, 0x0d, 0xea, 0xb1, 0xd9, 0xdc, 0x89, 0xbd, 0xa8, 0x08, 0x81, +0x18, 0x93, 0x77, 0x31, 0x50, 0xf7, 0x9e, 0x5d, 0x24, 0x86, 0xf5, 0x6f, +0x61, 0x49, 0x6e, 0x98, 0x54, 0xd7, 0xf0, 0x92, 0x86, 0xf1, 0x1c, 0x77, +0x3e, 0x0c, 0xe1, 0x21, 0x74, 0x93, 0x2f, 0x18, 0xa4, 0x8d, 0x01, 0x86, +0x25, 0xbb, 0x1d, 0x2e, 0x4c, 0xf2, 0xbb, 0x8d, 0x72, 0xdd, 0x1d, 0xb7, +0xc8, 0x21, 0x10, 0x8d, 0xf2, 0xa1, 0xa5, 0x70, 0x2f, 0xb1, 0xe7, 0xce, +0x4e, 0xa2, 0x62, 0x58, 0xf1, 0x10, 0x53, 0xe8, 0x45, 0x58, 0x0f, 0x63, +0xc7, 0xbd, 0x14, 0x13, 0x4b, 0x6d, 0x43, 0x61, 0xa3, 0x5e, 0x13, 0xc9, +0x7a, 0x68, 0x07, 0x71, 0xc0, 0xb0, 0x38, 0x9b, 0x2d, 0x7b, 0x0f, 0x85, +0x8a, 0x41, 0xf8, 0x7b, 0x3b, 0xce, 0x74, 0x20, 0x10, 0xad, 0x88, 0x42, +0xcf, 0x3b, 0x1e, 0xc4, 0x01, 0xc3, 0xd2, 0x09, 0xc5, 0xda, 0x21, 0xc4, +0x1d, 0xe1, 0x25, 0x04, 0xa2, 0xf6, 0x04, 0xf3, 0x08, 0xee, 0x30, 0xe2, +0x80, 0x61, 0xf9, 0xe6, 0xdb, 0xc1, 0x1c, 0x1f, 0xed, 0x36, 0x10, 0x85, +0xb2, 0xe2, 0xd0, 0x6a, 0x5f, 0x1b, 0x0c, 0x1b, 0xc1, 0x03, 0x71, 0x94, +0xba, 0x16, 0x15, 0x85, 0xd9, 0xf7, 0xbd, 0x19, 0x6e, 0x27, 0x83, 0x38, +0x60, 0x58, 0x33, 0x17, 0x07, 0x01, 0x9e, 0x42, 0xbe, 0x5d, 0x09, 0xe2, +0x80, 0x61, 0x4d, 0x19, 0xad, 0xbf, 0x13, 0xf2, 0x38, 0xa7, 0x40, 0x3f, +0xa3, 0xbf, 0x75, 0xd8, 0x88, 0x03, 0x86, 0x35, 0x17, 0x6a, 0xe2, 0x4c, +0x44, 0x0a, 0x6f, 0x61, 0xa4, 0x96, 0x16, 0xf6, 0xca, 0x4c, 0x6d, 0x1b, +0xad, 0xe6, 0x38, 0x04, 0x87, 0x61, 0x4d, 0xb7, 0x86, 0x27, 0x1f, 0x11, +0xc7, 0x5b, 0x98, 0x7b, 0xf7, 0x16, 0xac, 0x10, 0xb8, 0xbf, 0xf7, 0x03, +0x6c, 0xee, 0x30, 0x44, 0x20, 0x38, 0x04, 0x87, 0x61, 0x6d, 0x9b, 0xdf, +0xe8, 0xc1, 0x09, 0xee, 0xbd, 0x7a, 0x0b, 0xe6, 0x16, 0xb2, 0xc5, 0x9d, +0xb8, 0xef, 0x58, 0xfe, 0x2d, 0x39, 0x07, 0x0c, 0x23, 0x69, 0x3d, 0x64, +0x18, 0xa9, 0xb7, 0x76, 0x17, 0xe6, 0x46, 0xb1, 0xc3, 0x62, 0x10, 0x22, +0x5f, 0xeb, 0xd5, 0xc5, 0x24, 0x18, 0x86, 0x35, 0x17, 0x6a, 0x82, 0x11, +0xc2, 0x48, 0x2a, 0x08, 0x2e, 0xcd, 0x1d, 0xc5, 0x8b, 0x36, 0x06, 0xa3, +0xb5, 0x38, 0x86, 0xe1, 0x41, 0x8c, 0xc0, 0xdc, 0xea, 0x62, 0x67, 0xc4, +0xe0, 0x54, 0xa8, 0xe8, 0xe8, 0x73, 0x92, 0x90, 0x92, 0xf6, 0xa3, 0x67, +0x52, 0x61, 0x18, 0x25, 0xaf, 0x5d, 0x0b, 0x43, 0xab, 0x1e, 0x43, 0xe0, +0x21, 0x64, 0xf1, 0xb0, 0x44, 0x8c, 0x0e, 0xf4, 0x7b, 0xc1, 0x30, 0x0c, +0x81, 0x40, 0x18, 0x32, 0x57, 0x1b, 0xe4, 0x14, 0x85, 0xd5, 0xd0, 0x12, +0xde, 0x03, 0x86, 0x75, 0x67, 0x13, 0xb2, 0xd0, 0x98, 0x30, 0x98, 0x4a, +0xa3, 0x52, 0xa2, 0xf0, 0x21, 0x31, 0x8d, 0xf7, 0x80, 0x61, 0xf4, 0x66, +0x22, 0xf9, 0x5c, 0x47, 0xe8, 0x68, 0xaa, 0xe8, 0xa5, 0xdd, 0xf4, 0x4a, +0xc3, 0x1d, 0x97, 0x91, 0x60, 0x18, 0xc6, 0x69, 0xea, 0xea, 0x69, 0xe6, +0x0c, 0x43, 0x20, 0x0a, 0x55, 0x8a, 0xac, 0x0a, 0x04, 0xe1, 0x25, 0x0c, +0x23, 0xf7, 0x80, 0x30, 0x24, 0x16, 0x84, 0x5a, 0x42, 0x47, 0x7b, 0x9f, +0x29, 0x02, 0x81, 0x61, 0x94, 0xb6, 0xb6, 0x1e, 0x4a, 0xaa, 0x52, 0x18, +0x56, 0x4e, 0x2d, 0x37, 0x85, 0x5e, 0x87, 0x8a, 0x40, 0x60, 0x18, 0xe2, +0x40, 0xf2, 0xb9, 0xb3, 0x04, 0xf3, 0x15, 0xb4, 0x21, 0x1f, 0x02, 0x81, +0xf5, 0x6a, 0xa3, 0x8d, 0xe9, 0x91, 0x7a, 0x2f, 0xdd, 0x6b, 0xbb, 0x98, +0xc7, 0xe4, 0x13, 0x9a, 0xaf, 0x0a, 0xb0, 0xcf, 0x56, 0x05, 0x82, 0xde, +0x4b, 0x58, 0x6f, 0xe2, 0x30, 0xd2, 0x98, 0x1e, 0xa9, 0xa5, 0xc6, 0x52, +0xa1, 0xb7, 0x30, 0xf5, 0xf2, 0x70, 0x43, 0xe1, 0xe5, 0x90, 0x1c, 0xd6, +0xa3, 0x95, 0xec, 0x46, 0x2c, 0x73, 0x4a, 0x4c, 0xbe, 0xbf, 0x58, 0xea, +0xf0, 0xb8, 0x17, 0x87, 0xee, 0x2b, 0x96, 0xee, 0x35, 0x84, 0x93, 0x82, +0x10, 0xd2, 0xad, 0x77, 0xf1, 0x55, 0x81, 0xa0, 0x07, 0x13, 0xd6, 0x8b, +0xc9, 0x38, 0xce, 0x55, 0xb6, 0xad, 0x42, 0x20, 0xde, 0x8a, 0x9a, 0x0a, +0x83, 0x9a, 0xe6, 0xfa, 0x52, 0xcc, 0x2f, 0xbf, 0x56, 0x75, 0x7f, 0xd6, +0xa1, 0x78, 0xcf, 0x24, 0xd3, 0xf7, 0xa8, 0xcb, 0x87, 0xfd, 0x2c, 0x64, +0xf7, 0xeb, 0xd7, 0x2f, 0x4e, 0x52, 0x63, 0x5d, 0x79, 0x0f, 0xa9, 0xc3, +0x4b, 0x7a, 0x4f, 0xbb, 0x9a, 0x7c, 0xbf, 0xe0, 0xbe, 0x95, 0x69, 0x65, +0x2d, 0x79, 0x9c, 0xdd, 0x92, 0xb9, 0x78, 0x55, 0x34, 0x4c, 0xc8, 0x9b, +0x90, 0x52, 0x06, 0x6f, 0xa1, 0x67, 0xf7, 0xec, 0xf6, 0x2a, 0x9f, 0x43, +0xab, 0x0d, 0xac, 0xa7, 0xdc, 0x43, 0xca, 0x70, 0xa9, 0x7e, 0x7d, 0x0d, +0xcb, 0x46, 0x08, 0x43, 0xbf, 0x5f, 0x71, 0xfc, 0x4a, 0x2c, 0x4c, 0x03, +0xcf, 0xc9, 0x0d, 0xc2, 0x5c, 0x38, 0xaf, 0xd0, 0xbb, 0x6b, 0xb6, 0x2b, +0x6c, 0x47, 0x27, 0x57, 0xac, 0x17, 0x93, 0x45, 0x3b, 0xd5, 0x38, 0x96, +0x8d, 0x94, 0x78, 0xdb, 0x9a, 0xdf, 0x48, 0xb0, 0xb9, 0xbc, 0x7b, 0x9b, +0x36, 0x7e, 0x1d, 0xaa, 0x6d, 0xc6, 0x2d, 0x67, 0x58, 0xa9, 0x40, 0x97, +0xd4, 0xd2, 0x4c, 0x7b, 0x9f, 0xaf, 0x1e, 0x96, 0xa3, 0x92, 0x09, 0x6b, +0x5d, 0x1c, 0x52, 0x78, 0x0f, 0x32, 0x8f, 0xf4, 0x6b, 0x7b, 0xf1, 0x59, +0x1c, 0xf7, 0x3d, 0xa7, 0x17, 0x88, 0xcc, 0xc2, 0x30, 0xd2, 0x0b, 0x3d, +0xec, 0x99, 0xc9, 0xce, 0x88, 0x4a, 0x26, 0xac, 0xd5, 0xb0, 0x92, 0x8c, +0x5f, 0xb1, 0xd8, 0x9b, 0x4e, 0xfd, 0xda, 0x32, 0x37, 0x46, 0xa9, 0x16, +0x1a, 0xc5, 0x83, 0x58, 0x06, 0x7d, 0x99, 0xa7, 0x72, 0x3a, 0x1a, 0x57, +0xa5, 0x92, 0x09, 0x6b, 0x4d, 0x1c, 0x64, 0xdc, 0xa6, 0x10, 0x07, 0x5b, +0x02, 0x3e, 0x4a, 0xb5, 0x50, 0xd7, 0x02, 0xe1, 0xbf, 0xde, 0xa8, 0xc2, +0x70, 0xa9, 0x4c, 0x98, 0x44, 0x35, 0xd6, 0x9a, 0x69, 0xee, 0x2c, 0x45, +0xde, 0x61, 0xc5, 0x73, 0x40, 0x1c, 0x5a, 0xd9, 0xed, 0x6e, 0x08, 0xc3, +0x3c, 0xf0, 0x4b, 0x9c, 0xae, 0x8a, 0xad, 0x4e, 0x36, 0xf2, 0x10, 0x58, +0xed, 0xa6, 0x39, 0x81, 0x94, 0x6d, 0xea, 0x55, 0x1c, 0xcc, 0xda, 0x02, +0xad, 0x79, 0x11, 0x1d, 0x1f, 0x68, 0x3b, 0x24, 0x0e, 0x31, 0x5d, 0x75, +0xf2, 0x10, 0x58, 0xcd, 0xe1, 0x24, 0xad, 0x24, 0x4a, 0x55, 0xad, 0x24, +0xeb, 0x51, 0x90, 0x8f, 0x43, 0x1c, 0x4a, 0x87, 0x46, 0xf6, 0xf6, 0x5d, +0xea, 0xa5, 0x51, 0x5e, 0x6d, 0x1e, 0x98, 0x8d, 0xb7, 0xa6, 0x88, 0xe5, +0x96, 0xde, 0x6d, 0xb2, 0xb8, 0xfe, 0x6d, 0xff, 0xd0, 0xaa, 0x30, 0xa8, +0xc7, 0x20, 0xe3, 0x33, 0xa5, 0x97, 0x2b, 0xdf, 0x27, 0x98, 0x03, 0xac, +0x33, 0x15, 0xed, 0x84, 0x97, 0x0d, 0x43, 0x10, 0x82, 0x67, 0x15, 0xbb, +0x2d, 0x89, 0x6d, 0xb9, 0xd1, 0x4b, 0x1e, 0x42, 0xdb, 0x20, 0xb0, 0xf3, +0xfe, 0xb7, 0xe5, 0x43, 0xab, 0x1e, 0x83, 0x8e, 0xcb, 0xd4, 0xed, 0x33, +0x36, 0x0a, 0x35, 0x26, 0x96, 0x1b, 0x68, 0x26, 0x24, 0x97, 0xaa, 0xcb, +0xad, 0xba, 0xd6, 0x3d, 0x09, 0x84, 0xf6, 0xc5, 0x71, 0x83, 0x27, 0x72, +0x5b, 0xcc, 0x2b, 0x69, 0x4e, 0x4c, 0x85, 0x21, 0xb5, 0xf7, 0xf3, 0xa4, +0x48, 0x83, 0x8d, 0x29, 0x8c, 0xe9, 0x35, 0xb8, 0x8e, 0x7b, 0x32, 0xe9, +0xee, 0x73, 0x64, 0x71, 0xc8, 0xd1, 0x93, 0x28, 0x85, 0x30, 0xd8, 0x56, +0x16, 0x39, 0xc6, 0xe2, 0x96, 0x38, 0x8c, 0xd4, 0x42, 0x1b, 0x1a, 0xce, +0xd1, 0xb8, 0x4c, 0xfd, 0xaa, 0x54, 0x20, 0x5a, 0xaf, 0x64, 0xd2, 0x2a, +0x97, 0x91, 0xbd, 0x87, 0x54, 0xa7, 0x8a, 0x53, 0xbe, 0x33, 0x5d, 0xa8, +0x73, 0xbe, 0x3b, 0xf5, 0x54, 0xd6, 0x36, 0x13, 0x23, 0x5d, 0xc0, 0x03, +0x0d, 0x86, 0x93, 0x5c, 0xe6, 0x46, 0x86, 0x2a, 0x10, 0xad, 0xef, 0xbc, +0x5b, 0xdc, 0x39, 0xc7, 0xf4, 0x9c, 0xb4, 0x5f, 0x50, 0x4b, 0xc2, 0x90, +0xb2, 0x32, 0xe9, 0x95, 0xe7, 0xb0, 0xf5, 0xac, 0x7c, 0x58, 0x8b, 0xf3, +0x0f, 0x50, 0x9d, 0x30, 0x4c, 0x25, 0xee, 0xc6, 0x48, 0x5d, 0x5b, 0x9e, +0x6b, 0x47, 0x28, 0x8b, 0xcd, 0xa8, 0xf9, 0x86, 0x96, 0xde, 0x9f, 0xbe, +0x2b, 0xb1, 0x9c, 0xc2, 0x60, 0xab, 0xa2, 0x76, 0x3c, 0xab, 0x89, 0x25, +0x09, 0x6a, 0x11, 0x86, 0xa2, 0xf7, 0x62, 0x58, 0x17, 0xbf, 0xe5, 0xdd, +0xf3, 0x88, 0xa1, 0x25, 0x7b, 0xaa, 0xb8, 0xf6, 0x77, 0x64, 0x85, 0x21, +0xb7, 0xa7, 0x77, 0x22, 0x8c, 0xb5, 0xb0, 0x34, 0x41, 0x69, 0xa6, 0x1a, +0x6a, 0xd4, 0x5b, 0x16, 0x08, 0xad, 0xc2, 0x1a, 0x31, 0xb4, 0xd4, 0xc2, +0x21, 0x47, 0x9b, 0x7c, 0x2e, 0xe5, 0xe5, 0xbc, 0x0a, 0x29, 0x11, 0x66, +0x82, 0xda, 0xb8, 0xa7, 0x2a, 0x5b, 0x1d, 0x4d, 0x20, 0xf4, 0x80, 0xd3, +0xa8, 0xe2, 0x50, 0xeb, 0x01, 0x47, 0xf5, 0x16, 0x72, 0x96, 0xac, 0x26, +0x08, 0x65, 0x11, 0x66, 0x82, 0xec, 0xe1, 0xa4, 0xa5, 0xb6, 0x09, 0xdd, +0xaa, 0x40, 0x8c, 0xda, 0x68, 0xd0, 0x76, 0x1b, 0xad, 0x6d, 0x2c, 0xd5, +0x20, 0x0c, 0xb6, 0x67, 0xd3, 0x95, 0x67, 0x44, 0x35, 0x13, 0x64, 0xf5, +0x1a, 0x4a, 0x24, 0xa0, 0x7b, 0x15, 0x88, 0xd6, 0x12, 0xb3, 0xb1, 0xbd, +0xa6, 0x9a, 0x5a, 0xb4, 0xcb, 0xe7, 0x58, 0x13, 0x86, 0x12, 0xc2, 0x6d, +0xbb, 0xb1, 0x46, 0xfa, 0xfe, 0xf4, 0x64, 0x82, 0xe4, 0x2c, 0x35, 0xf7, +0xc3, 0x69, 0x4d, 0x20, 0x6c, 0x78, 0x65, 0x54, 0x71, 0xa8, 0x45, 0x18, +0xb5, 0x54, 0xb5, 0xb4, 0x30, 0xd8, 0xcf, 0x12, 0x33, 0x1f, 0x85, 0x17, +0x01, 0x29, 0x99, 0x6b, 0xf5, 0x1a, 0x5a, 0x16, 0x88, 0xde, 0x5a, 0x83, +0x1c, 0x7d, 0x4f, 0xa5, 0x85, 0x71, 0xcd, 0x63, 0x28, 0x79, 0x40, 0xd1, +0xde, 0x2c, 0x17, 0xfb, 0x33, 0xf8, 0x8d, 0x1d, 0x6d, 0x37, 0x60, 0x3c, +0x61, 0x68, 0x51, 0x20, 0x7a, 0x38, 0xb3, 0x71, 0x25, 0xa4, 0x56, 0xf2, +0xc4, 0xbb, 0x3d, 0xdc, 0xa6, 0x9f, 0xa5, 0x64, 0x05, 0x99, 0xad, 0x90, +0x4a, 0x3c, 0x1e, 0x28, 0x79, 0x85, 0xf1, 0x84, 0xa1, 0x35, 0x81, 0x08, +0x13, 0x8f, 0xf2, 0xac, 0x47, 0x68, 0xeb, 0x6d, 0x1b, 0x2a, 0x96, 0x12, +0xc6, 0xd0, 0x63, 0x28, 0x2d, 0x0c, 0xfa, 0x59, 0x72, 0x78, 0x2e, 0x78, +0x11, 0x70, 0x85, 0x49, 0x76, 0x18, 0x2d, 0x0a, 0xc3, 0xda, 0xc2, 0xdb, +0x8a, 0x38, 0xb8, 0xbf, 0x25, 0x88, 0x32, 0x71, 0x67, 0x89, 0x15, 0xf7, +0x2a, 0x16, 0x67, 0xea, 0xf8, 0x63, 0x86, 0x6f, 0xec, 0x39, 0x06, 0xf9, +0xef, 0x12, 0xc2, 0xa0, 0x2d, 0xdc, 0xe5, 0x7b, 0x6b, 0x4b, 0x95, 0xcc, +0x21, 0x2d, 0xbc, 0x08, 0x38, 0x44, 0xf6, 0x9e, 0x49, 0xa9, 0x63, 0xfa, +0x35, 0x86, 0x6d, 0xec, 0x02, 0x65, 0xc4, 0xe1, 0xfe, 0xe4, 0x9d, 0xcc, +0xad, 0x0b, 0x76, 0x2d, 0x09, 0x79, 0x8d, 0xed, 0x97, 0xce, 0x31, 0xb8, +0x0a, 0x2e, 0x3e, 0xa2, 0xc3, 0x2b, 0xec, 0xe5, 0xd1, 0x65, 0xb5, 0xa7, +0xdd, 0x6a, 0xad, 0xdd, 0x5c, 0xc3, 0x05, 0xea, 0x84, 0xab, 0x7f, 0x6f, +0x5d, 0x30, 0x54, 0x1c, 0x73, 0xbf, 0x9b, 0xf0, 0x5e, 0x86, 0x12, 0x0b, +0xb2, 0x78, 0x85, 0x35, 0x1d, 0x28, 0x75, 0x94, 0xbc, 0xc2, 0x48, 0xc2, +0xe0, 0x2a, 0xbe, 0x51, 0x2e, 0x5c, 0xa0, 0xfc, 0x02, 0x3f, 0x45, 0x78, +0x87, 0x0f, 0xc1, 0x90, 0x85, 0xa7, 0xf6, 0x1c, 0x46, 0xa9, 0xd0, 0x9f, +0xf5, 0x5a, 0x52, 0x0b, 0x93, 0x7a, 0x06, 0x46, 0x0c, 0x96, 0xe0, 0x3d, +0xdf, 0x6a, 0x11, 0x78, 0x3f, 0x56, 0x00, 0x3e, 0x87, 0x2d, 0x7a, 0x8d, +0x6f, 0xeb, 0x62, 0x50, 0xcb, 0xc1, 0x2b, 0x7b, 0x3f, 0x80, 0x96, 0x2d, +0xfa, 0x85, 0xe3, 0x9e, 0x58, 0xfc, 0x67, 0x5d, 0xa4, 0x64, 0x31, 0x2a, +0xbd, 0x20, 0xd9, 0xf7, 0x92, 0x53, 0xb8, 0x35, 0x21, 0xfe, 0xaa, 0x64, +0x54, 0x17, 0x76, 0x35, 0x7d, 0x66, 0x6a, 0xc1, 0x82, 0x1f, 0xde, 0x2b, +0x3f, 0x99, 0x5f, 0x8f, 0xf4, 0x3b, 0xaa, 0x21, 0xa4, 0x8b, 0x17, 0x01, +0x7f, 0x07, 0x64, 0xef, 0x55, 0x32, 0xb5, 0xd4, 0xd6, 0x87, 0x21, 0x25, +0xd3, 0xa2, 0xa1, 0xe4, 0x84, 0xbc, 0x07, 0xf6, 0x49, 0x44, 0xd4, 0x0b, +0x89, 0x19, 0x23, 0xb7, 0x55, 0x4b, 0x39, 0x43, 0x4b, 0xf6, 0x4e, 0x89, +0x8d, 0x85, 0x7e, 0x36, 0xcf, 0xe2, 0x76, 0xe0, 0x19, 0x1e, 0x15, 0x82, +0x67, 0x4c, 0xe4, 0x22, 0xa0, 0x34, 0x53, 0x2f, 0x49, 0xce, 0x5a, 0xc3, +0x18, 0xaf, 0xc4, 0xc1, 0x3f, 0xff, 0xd6, 0x4a, 0x0b, 0x6f, 0x2b, 0xa2, +0xa2, 0xbb, 0xe5, 0x5d, 0x26, 0x8b, 0x71, 0x29, 0xd1, 0x36, 0x15, 0x4a, +0xb5, 0x57, 0xec, 0x94, 0xee, 0x82, 0x4c, 0x45, 0xd3, 0xa8, 0x79, 0x86, +0xca, 0x92, 0x62, 0x5d, 0x97, 0x50, 0x86, 0x9f, 0x21, 0xf0, 0x1c, 0xa6, +0x11, 0x07, 0xa0, 0x8c, 0xbf, 0x12, 0xde, 0x83, 0x7c, 0x2f, 0xff, 0xfd, +0x5a, 0x09, 0xa1, 0xdc, 0x4a, 0x6d, 0xe2, 0x68, 0x05, 0x3e, 0xa8, 0x38, +0x8c, 0x70, 0xe8, 0x6a, 0x2b, 0x94, 0x51, 0x22, 0x41, 0x6d, 0xf3, 0x0d, +0xba, 0x20, 0x36, 0xea, 0x39, 0x44, 0x1b, 0x83, 0xd6, 0x7b, 0xc8, 0x35, +0x1e, 0xb5, 0x75, 0x46, 0x8b, 0x3b, 0xe3, 0x82, 0x9e, 0x3e, 0x5e, 0xc4, +0x40, 0xcc, 0xa3, 0x89, 0x83, 0x0b, 0x2a, 0x85, 0x4a, 0xb4, 0x64, 0x56, +0x71, 0x32, 0x09, 0xd1, 0x65, 0xe4, 0x9d, 0x59, 0x29, 0xef, 0xa1, 0x82, +0x5c, 0x4f, 0x73, 0x9e, 0x04, 0x5e, 0xc4, 0x18, 0xdc, 0x46, 0x0b, 0x29, +0xb9, 0xbf, 0x1d, 0x2a, 0x97, 0x52, 0xe1, 0xa5, 0x8d, 0xf3, 0x0d, 0xc3, +0xef, 0xc8, 0x72, 0x5f, 0x02, 0x24, 0xdf, 0xcf, 0x0b, 0x73, 0xeb, 0x95, +0x39, 0xb7, 0x12, 0x1b, 0x3c, 0x3a, 0xbd, 0xf6, 0xcd, 0x34, 0x9a, 0xd7, +0xe0, 0x07, 0xf4, 0xe4, 0x7f, 0xfe, 0x45, 0x17, 0xe9, 0x9c, 0xcf, 0xc1, +0xde, 0xe3, 0x20, 0x8b, 0x53, 0xa4, 0xf3, 0x0d, 0x5d, 0x8c, 0xc7, 0x9c, +0x87, 0xe2, 0x1a, 0xcc, 0x39, 0xd4, 0x1a, 0x22, 0x66, 0xec, 0xf6, 0xe6, +0x35, 0xb8, 0x4e, 0x5a, 0x64, 0xb8, 0xfd, 0x65, 0x79, 0x5a, 0x9e, 0xf8, +0xc1, 0x2d, 0xcf, 0xe9, 0x3d, 0xd8, 0x7c, 0x83, 0x2c, 0x4c, 0x26, 0xac, +0x81, 0x9b, 0x6e, 0xbc, 0x87, 0x1c, 0xd5, 0x64, 0xda, 0xcb, 0xc8, 0xf5, +0x57, 0xd3, 0x9f, 0xfd, 0x52, 0x2e, 0xca, 0x5e, 0x3b, 0xdb, 0xa5, 0x8d, +0x50, 0xbe, 0x6a, 0x42, 0x36, 0x5b, 0xc9, 0xde, 0x59, 0xdb, 0x36, 0xe7, +0x0e, 0x29, 0xc9, 0xc2, 0xe4, 0x3d, 0x19, 0x84, 0xe1, 0x2f, 0x4b, 0x2e, +0xef, 0xa1, 0xa3, 0xb0, 0x52, 0x35, 0x22, 0xe1, 0x38, 0x3c, 0xd7, 0xc7, +0x24, 0xec, 0x5d, 0x14, 0x4c, 0x08, 0xe9, 0xe9, 0xe2, 0xab, 0xc9, 0xd0, +0x1c, 0x95, 0x4b, 0x1a, 0x52, 0xd2, 0x66, 0x6f, 0xc4, 0x6d, 0x3f, 0x2f, +0x68, 0xf6, 0x19, 0xa5, 0x16, 0x87, 0x41, 0x42, 0x7a, 0x59, 0x13, 0xd7, +0xb4, 0x03, 0x6f, 0x7c, 0xb0, 0xf4, 0x9a, 0x88, 0x36, 0x9e, 0xc2, 0x7c, +0x60, 0x80, 0xde, 0xb4, 0x43, 0x6a, 0x0e, 0x71, 0xd0, 0x7e, 0x3e, 0x8d, +0x57, 0xca, 0x24, 0xc3, 0x56, 0x2e, 0xa5, 0x14, 0xec, 0x4c, 0x2d, 0x4b, +0x86, 0xf5, 0x24, 0x08, 0x35, 0x11, 0x52, 0xaa, 0xc9, 0x4b, 0x58, 0xdc, +0xf9, 0xf6, 0x05, 0x0f, 0x81, 0x48, 0x9d, 0x7b, 0xd0, 0x98, 0x3a, 0x67, +0x1b, 0xf6, 0x79, 0x0f, 0xa9, 0xdf, 0xc7, 0xa0, 0xef, 0x20, 0x77, 0xb8, +0x89, 0xb3, 0x11, 0x2d, 0x89, 0x43, 0x0f, 0x55, 0x4a, 0x7e, 0x80, 0xab, +0x97, 0x70, 0x8b, 0xb5, 0x28, 0xa5, 0x8e, 0x75, 0x8b, 0x87, 0x72, 0xb2, +0x45, 0xf7, 0x70, 0xde, 0x43, 0xca, 0x5c, 0x90, 0xe9, 0x11, 0x35, 0x0d, +0xfa, 0x98, 0x73, 0x9f, 0x93, 0x98, 0x18, 0xd9, 0xf5, 0x33, 0xb7, 0x2c, +0x08, 0xc6, 0x4b, 0x48, 0xb1, 0xb0, 0xce, 0x5a, 0x62, 0x9a, 0xc3, 0x7b, +0x20, 0xac, 0xf4, 0xda, 0x7b, 0x48, 0xf5, 0x2e, 0x4c, 0x42, 0x7a, 0xf4, +0x45, 0x2b, 0x9b, 0x48, 0xf8, 0xef, 0x43, 0x01, 0x46, 0xc5, 0x34, 0x95, +0x8c, 0x0e, 0x3c, 0x84, 0x1c, 0x3b, 0xed, 0xc5, 0xf4, 0x3b, 0x4a, 0xe6, +0x3d, 0x98, 0xc3, 0x5e, 0x78, 0x0f, 0x4f, 0xbc, 0x87, 0x54, 0xb9, 0x20, +0x6d, 0xc1, 0x8d, 0x38, 0xfc, 0x15, 0x89, 0x8c, 0xb9, 0x48, 0x42, 0x4d, +0x83, 0x0f, 0x80, 0xcb, 0x13, 0x37, 0x38, 0xb4, 0x96, 0x55, 0x40, 0x53, +0x7b, 0x10, 0xa6, 0xce, 0x9e, 0x89, 0xf2, 0xc2, 0x7b, 0x48, 0x21, 0xd4, +0x84, 0x95, 0xaa, 0x08, 0x37, 0xb1, 0x31, 0xaa, 0x69, 0xc2, 0xd5, 0x9c, +0x8c, 0x0e, 0x2e, 0x4b, 0x29, 0xed, 0x7e, 0x4e, 0x22, 0x0e, 0x29, 0x3d, +0x08, 0xb3, 0x7b, 0xc5, 0xd5, 0xde, 0x10, 0xe9, 0x54, 0xde, 0x03, 0x61, +0xa5, 0xd7, 0x22, 0x91, 0x23, 0x37, 0xc9, 0xf8, 0xaf, 0x87, 0xea, 0x1a, +0xed, 0x99, 0x05, 0xf2, 0x4a, 0xb5, 0x51, 0xb2, 0x09, 0x62, 0x16, 0x11, +0x0e, 0x0f, 0x15, 0x7a, 0xfe, 0x29, 0xbc, 0x07, 0xf1, 0x4a, 0x10, 0x87, +0x7d, 0x1b, 0xca, 0x4c, 0x6b, 0x06, 0x1e, 0x74, 0xe9, 0x9d, 0x98, 0xab, +0xf3, 0x5c, 0x42, 0xd5, 0x3b, 0x07, 0xf1, 0x66, 0x32, 0x08, 0x04, 0x8b, +0xd4, 0xc6, 0x86, 0xc6, 0x5c, 0xcc, 0x13, 0x35, 0xac, 0x87, 0x38, 0xd4, +0x25, 0x12, 0x74, 0x7c, 0x45, 0x1c, 0xac, 0x28, 0x4c, 0x0d, 0x0d, 0x86, +0x39, 0xe6, 0x15, 0x99, 0x08, 0xc4, 0x7e, 0xef, 0x41, 0x0f, 0x0f, 0xba, +0x34, 0x39, 0x1f, 0x9e, 0x79, 0x65, 0x22, 0x41, 0xe7, 0x80, 0x02, 0x93, +0xac, 0x86, 0x64, 0xb4, 0x69, 0x82, 0x77, 0x6b, 0x75, 0x62, 0x24, 0x9e, +0x1c, 0x84, 0x98, 0x56, 0x36, 0x35, 0xda, 0x72, 0x24, 0x66, 0x58, 0x89, +0x72, 0xe2, 0x6b, 0xeb, 0x49, 0x86, 0xfc, 0x25, 0xef, 0x26, 0xd7, 0xc2, +0x56, 0x3a, 0x19, 0xdd, 0x51, 0xe9, 0x60, 0x52, 0x0f, 0x8c, 0x9d, 0xd3, +0xba, 0xf7, 0x10, 0x33, 0x31, 0x2d, 0x42, 0x43, 0xb5, 0x58, 0x9c, 0x77, +0x93, 0xba, 0x68, 0xc3, 0x51, 0xd5, 0xd4, 0xb7, 0x38, 0x74, 0xd8, 0x4b, +0x28, 0xe9, 0xce, 0x89, 0xf8, 0x6b, 0x1e, 0xef, 0x81, 0x1e, 0x40, 0x6d, +0x84, 0x9b, 0xd8, 0x30, 0x35, 0x1e, 0x2b, 0x74, 0xe7, 0x5b, 0x67, 0xb7, +0xcc, 0xe4, 0x48, 0x54, 0x67, 0x19, 0xbf, 0x29, 0xbc, 0x07, 0x2f, 0x36, +0xec, 0x4c, 0xdb, 0xd9, 0x84, 0xe2, 0xe9, 0xf5, 0xe2, 0x39, 0x34, 0x9e, +0x63, 0x38, 0x42, 0xb2, 0xb6, 0x24, 0xec, 0x9a, 0xd2, 0x79, 0x0f, 0x74, +0xc7, 0x6d, 0x73, 0xbd, 0x61, 0x4e, 0x44, 0xde, 0xe1, 0xe6, 0x16, 0x87, +0x41, 0x6f, 0x3a, 0x4b, 0x99, 0x8f, 0x18, 0x7d, 0x87, 0x1b, 0xdd, 0x7b, +0x70, 0x24, 0x3e, 0xf1, 0x24, 0x20, 0x6f, 0x58, 0x69, 0xf0, 0x2b, 0x30, +0x53, 0xe6, 0x23, 0x86, 0x9e, 0x0c, 0x29, 0x2e, 0x67, 0x62, 0x17, 0xda, +0x85, 0x48, 0x20, 0xf0, 0xad, 0x84, 0x95, 0x06, 0xbb, 0x48, 0x65, 0x53, +0x24, 0x12, 0x7a, 0x12, 0xa3, 0x4e, 0x86, 0xe8, 0x57, 0xbb, 0xd2, 0xc2, +0x21, 0x6f, 0x04, 0xc3, 0x51, 0xd9, 0x34, 0xd4, 0x6e, 0xb6, 0xd7, 0x92, +0xd5, 0xa8, 0x8b, 0x5a, 0x6c, 0xcf, 0x6d, 0xd4, 0xc9, 0xa0, 0xde, 0x43, +0xac, 0x53, 0xd3, 0x2c, 0x2a, 0x45, 0x48, 0x16, 0x7e, 0xa5, 0xd2, 0xef, +0xe4, 0xa4, 0xca, 0xe4, 0x39, 0x10, 0x07, 0xcc, 0xb8, 0x73, 0x1a, 0x70, +0x71, 0x9b, 0xc4, 0x7b, 0x88, 0x9c, 0x7b, 0x60, 0x33, 0xd3, 0x99, 0x48, +0x10, 0x2e, 0xac, 0xe4, 0x45, 0xe0, 0x35, 0x94, 0xf7, 0x24, 0x46, 0xba, +0xf6, 0x32, 0x41, 0xee, 0x81, 0x98, 0x75, 0xbf, 0x1b, 0x57, 0xde, 0xed, +0x0e, 0xee, 0x2e, 0x4f, 0xae, 0x01, 0x97, 0xee, 0x80, 0x48, 0xe0, 0x49, +0x54, 0xe1, 0x3d, 0xe0, 0xed, 0x96, 0x27, 0x75, 0xe8, 0x9b, 0x4d, 0x6b, +0x29, 0x85, 0xc6, 0x6b, 0xa8, 0xcb, 0x93, 0xe8, 0x5d, 0x24, 0x64, 0x2c, +0xc7, 0x3a, 0xf7, 0x40, 0x9c, 0x7a, 0x0c, 0x91, 0xe0, 0x3d, 0xbf, 0xd8, +0x71, 0x39, 0xda, 0x63, 0x54, 0xfd, 0x7e, 0x10, 0x89, 0xfd, 0x8b, 0x88, +0xe9, 0x91, 0x44, 0xf8, 0x01, 0x91, 0xa0, 0x42, 0xed, 0xea, 0x03, 0x4f, +0x71, 0xde, 0x61, 0xa4, 0x78, 0x77, 0xe3, 0x22, 0xd1, 0xdb, 0x84, 0x98, +0x63, 0x5d, 0xe9, 0x4a, 0x02, 0x73, 0x58, 0x91, 0x60, 0xdd, 0xb2, 0x13, +0xca, 0x91, 0x6b, 0x68, 0x85, 0x7b, 0xa2, 0xc4, 0x75, 0x37, 0xef, 0x4a, +0xc6, 0x5e, 0x0c, 0xef, 0x81, 0x92, 0xd6, 0xf1, 0x36, 0x4c, 0xbc, 0xfb, +0x3c, 0xde, 0x03, 0x09, 0xbd, 0xc4, 0x13, 0x03, 0xd7, 0x7a, 0xfb, 0xd9, +0x98, 0x6b, 0x3f, 0x49, 0x5a, 0xb2, 0x61, 0xba, 0x2a, 0x12, 0xc3, 0x8f, +0x81, 0xd8, 0xde, 0x03, 0xf1, 0xda, 0x46, 0x77, 0x4f, 0x3d, 0xb4, 0xad, +0x96, 0x9f, 0x21, 0x92, 0x38, 0xb0, 0xc9, 0x69, 0x48, 0x24, 0x12, 0x27, +0xae, 0x87, 0xf5, 0x24, 0x62, 0x7b, 0x0f, 0x88, 0x43, 0xe3, 0x9e, 0x44, +0xe3, 0x0b, 0xe3, 0xdd, 0xb4, 0xe0, 0x26, 0x2f, 0xc3, 0x5a, 0x86, 0x77, +0x5d, 0x91, 0xf7, 0xc0, 0x8e, 0xab, 0x13, 0x4f, 0xa2, 0x61, 0xa1, 0x5f, +0x22, 0x55, 0x2e, 0x31, 0x96, 0x09, 0x37, 0x91, 0x53, 0x8d, 0x75, 0xee, +0x81, 0x1b, 0xb5, 0xf0, 0x24, 0x6a, 0x20, 0x86, 0xf7, 0x80, 0x27, 0x4c, +0xb8, 0xc9, 0x71, 0x96, 0x2b, 0x9e, 0xda, 0x92, 0xed, 0xaf, 0x67, 0xf7, +0x3c, 0xb8, 0x48, 0xcc, 0xe2, 0x3d, 0x5c, 0x1d, 0xd3, 0x84, 0x97, 0xfa, +0x08, 0x37, 0x71, 0x97, 0x44, 0x25, 0xe1, 0x25, 0xea, 0xc4, 0xfb, 0xf3, +0x08, 0x5d, 0x83, 0x6d, 0xd8, 0xe5, 0x73, 0xc6, 0xf0, 0x1e, 0xf0, 0x86, +0xd9, 0x00, 0xe3, 0x4d, 0xb8, 0x7f, 0xab, 0x3d, 0x1c, 0x87, 0xac, 0xba, +0xdb, 0x39, 0x25, 0x9c, 0x14, 0x4b, 0xcd, 0x13, 0x22, 0xe2, 0x8e, 0x91, +0xfc, 0x43, 0x3f, 0x4c, 0xa9, 0x2f, 0x3c, 0xf3, 0x1b, 0xa8, 0xee, 0x84, +0x22, 0x4a, 0x53, 0x3e, 0x76, 0x5b, 0xe3, 0xed, 0x9c, 0x2a, 0x9d, 0x10, +0x31, 0x85, 0x91, 0xfc, 0x03, 0x91, 0x92, 0xe1, 0x85, 0x82, 0xf0, 0x52, +0xe7, 0x93, 0x22, 0xd3, 0xce, 0xa9, 0x96, 0xc5, 0x34, 0xa6, 0x40, 0xe0, +0x41, 0x20, 0x12, 0x57, 0xc7, 0xcf, 0x8d, 0x07, 0x86, 0x40, 0x0c, 0xed, +0x49, 0x54, 0xb6, 0x73, 0x42, 0x20, 0xe0, 0x15, 0xc9, 0xef, 0xb9, 0xe9, +0x69, 0x5d, 0x5c, 0x78, 0x10, 0xec, 0x9c, 0x5c, 0x3f, 0x75, 0xe2, 0x08, +0x04, 0xbc, 0x24, 0xe3, 0x4d, 0x99, 0x6d, 0x8f, 0xa3, 0x58, 0x09, 0x3d, +0x72, 0x10, 0x63, 0x8a, 0xc4, 0xd6, 0x79, 0x83, 0x82, 0x25, 0xcf, 0x08, +0x04, 0xd4, 0x28, 0x12, 0x53, 0x8b, 0xcf, 0x28, 0xda, 0x64, 0xa2, 0x8a, +0x69, 0x5c, 0xf7, 0x5a, 0xce, 0x1c, 0xac, 0x9d, 0x5a, 0x2e, 0x24, 0x12, +0x08, 0x04, 0x64, 0xdf, 0x20, 0xbb, 0x4e, 0x5b, 0x74, 0xdc, 0x1c, 0x8d, +0xac, 0xd8, 0x39, 0x45, 0x30, 0xb9, 0xb1, 0x6d, 0x4d, 0x24, 0x0a, 0x78, +0x96, 0x37, 0x47, 0x9b, 0x11, 0x38, 0x30, 0x5e, 0x72, 0x89, 0x44, 0x8b, +0x1b, 0x0e, 0x3c, 0x88, 0x41, 0x27, 0x45, 0xec, 0xa4, 0xb5, 0x84, 0x99, +0x7e, 0xfd, 0xfa, 0xf5, 0xb6, 0xf1, 0x75, 0xa7, 0x46, 0x7f, 0xb6, 0x89, +0xa1, 0xc2, 0xa6, 0xc9, 0x0d, 0x9c, 0xb0, 0x8e, 0x36, 0x99, 0xc8, 0x41, +0x34, 0xc7, 0x14, 0x7b, 0x02, 0x88, 0x40, 0x88, 0x27, 0x51, 0x7a, 0x6c, +0x44, 0xdc, 0x11, 0x22, 0x10, 0x88, 0x44, 0xec, 0x76, 0xe1, 0x63, 0x3e, +0x14, 0xaa, 0x98, 0x9a, 0x24, 0x6a, 0x3e, 0x42, 0xae, 0xf6, 0x14, 0x91, +0xa8, 0x60, 0xb1, 0x8d, 0x95, 0x8c, 0x27, 0x64, 0xca, 0x9c, 0x18, 0xfe, +0x4a, 0xdf, 0x58, 0x3b, 0x49, 0xe2, 0xb5, 0xed, 0x11, 0xf5, 0x7c, 0x84, +0xe4, 0x20, 0x7e, 0xff, 0xfe, 0xbd, 0x15, 0x66, 0xca, 0x39, 0x3e, 0x2e, +0x7b, 0xc6, 0x78, 0xc4, 0x43, 0x93, 0xb2, 0x24, 0xbc, 0xc9, 0x4d, 0xc7, +0xa5, 0x3e, 0x25, 0x4c, 0x26, 0x42, 0x4d, 0xea, 0x41, 0x6c, 0x09, 0x44, +0x6e, 0x0f, 0x33, 0x82, 0x67, 0x8c, 0xf7, 0x80, 0x27, 0x41, 0xb9, 0xab, +0xdd, 0x75, 0xf9, 0x0f, 0xbf, 0xc8, 0x82, 0xbf, 0x57, 0x30, 0xa8, 0x5e, +0x62, 0x32, 0x38, 0x93, 0x83, 0xd8, 0x0a, 0x31, 0x15, 0xd8, 0x44, 0x5c, +0xe9, 0x31, 0x46, 0x79, 0x2b, 0xa4, 0x6a, 0x76, 0x39, 0xf5, 0xf2, 0x80, +0xee, 0x2a, 0x18, 0xb2, 0x1b, 0x53, 0xd1, 0x50, 0xf3, 0x13, 0x7e, 0x41, +0x1c, 0xfa, 0xe0, 0xea, 0x8e, 0x5b, 0x92, 0xd3, 0xe2, 0x3d, 0x88, 0x17, +0xe1, 0x2a, 0xc9, 0x51, 0x9d, 0xf9, 0x99, 0xc8, 0xa5, 0x81, 0x5d, 0x03, +0x63, 0x26, 0xae, 0x47, 0xbe, 0xae, 0x14, 0x3a, 0xd8, 0x31, 0x9d, 0xa9, +0xfe, 0x91, 0xcd, 0x82, 0x26, 0xa7, 0xe5, 0xd7, 0x27, 0xbb, 0xae, 0x12, +0x3b, 0xa7, 0xdb, 0xde, 0x09, 0xee, 0xff, 0x1e, 0x9e, 0x03, 0xac, 0x71, +0xa9, 0xe1, 0xa5, 0xfc, 0xdb, 0x56, 0xee, 0x52, 0x01, 0x78, 0x39, 0x19, +0x64, 0x30, 0xef, 0x31, 0xf5, 0x2a, 0x43, 0xef, 0x32, 0x34, 0x57, 0xbe, +0x80, 0x61, 0xf6, 0x8b, 0xff, 0x96, 0x4d, 0xbc, 0x76, 0xd8, 0x11, 0x51, +0x59, 0xb6, 0xe6, 0xc2, 0xca, 0x98, 0x9a, 0xbd, 0x21, 0x0a, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0xc2, 0xc4, 0x23, 0x00, 0x00, 0x80, 0x35, +0x71, 0x58, 0x78, 0x0c, 0x00, 0x00, 0x60, 0xb9, 0x7d, 0xf9, 0xf2, 0xe5, +0xbf, 0x7f, 0x7e, 0x9d, 0x79, 0x14, 0x00, 0x00, 0xf0, 0xce, 0xd7, 0xaf, +0x5f, 0xff, 0xf3, 0xe7, 0x97, 0x37, 0x47, 0x88, 0x09, 0x00, 0x00, 0x02, +0xcf, 0xe1, 0xcd, 0xdb, 0x9d, 0x47, 0x02, 0x00, 0x00, 0xb3, 0x15, 0x07, +0xff, 0xdf, 0x00, 0x00, 0x30, 0xaa, 0xc7, 0xf0, 0xc7, 0x96, 0xc0, 0x6b, +0x78, 0x98, 0x0f, 0x33, 0x01, 0x00, 0xc0, 0x40, 0x48, 0xd8, 0x68, 0x16, +0x01, 0xf8, 0xf6, 0xed, 0xdb, 0xff, 0x42, 0x61, 0x30, 0x46, 0x82, 0x1a, +0x00, 0x60, 0x10, 0x51, 0x78, 0x78, 0x0a, 0x2f, 0x44, 0xe1, 0x61, 0xfe, +0xef, 0x00, 0x00, 0x40, 0xcf, 0xa2, 0x60, 0x2a, 0x92, 0x76, 0x1b, 0xe1, +0x25, 0x00, 0x80, 0x3e, 0x99, 0x76, 0x84, 0x8f, 0x5e, 0x19, 0xe1, 0x25, +0x00, 0x80, 0x9e, 0x3c, 0x86, 0x33, 0xde, 0x42, 0x68, 0x54, 0x2f, 0x01, +0x00, 0x74, 0x24, 0x0c, 0xb2, 0xe3, 0xbf, 0xe8, 0x31, 0x58, 0xa3, 0xbd, +0x06, 0x00, 0x40, 0xe3, 0xdc, 0x22, 0x0b, 0x83, 0x26, 0xa7, 0x6f, 0x3c, +0x5a, 0x00, 0x80, 0x76, 0x99, 0x62, 0x0a, 0x03, 0xde, 0x03, 0x00, 0x40, +0x1f, 0x5e, 0xc3, 0x92, 0x42, 0x1c, 0xc8, 0x3d, 0x00, 0x00, 0xb4, 0xcb, +0x3d, 0x91, 0xd7, 0xa0, 0x36, 0xf1, 0x88, 0x01, 0x00, 0x10, 0x87, 0xdc, +0xa1, 0xa5, 0x3b, 0x02, 0x04, 0x00, 0x10, 0x9f, 0x39, 0xa5, 0x38, 0xfc, +0xf8, 0xf1, 0xe3, 0x1f, 0x31, 0xf7, 0xb1, 0x73, 0xeb, 0xa3, 0x32, 0xca, +0xd8, 0xe4, 0x7f, 0xef, 0xe6, 0x8e, 0x27, 0xb1, 0x27, 0x1f, 0xbe, 0x42, +0x20, 0x00, 0x00, 0x22, 0x32, 0x7d, 0xff, 0xfe, 0x5d, 0x17, 0xf0, 0x24, +0xe2, 0xf0, 0xfb, 0xf7, 0xef, 0x37, 0x31, 0xff, 0x3d, 0x9e, 0x1e, 0xb2, +0x93, 0xdf, 0x17, 0x93, 0x05, 0x5f, 0xcc, 0x9f, 0xbb, 0x58, 0x8c, 0xa9, +0x98, 0xc8, 0xaf, 0x8b, 0xfe, 0x5d, 0xc4, 0x01, 0x00, 0x20, 0x2e, 0x8f, +0xb0, 0x52, 0x2a, 0x71, 0xd0, 0x05, 0x5f, 0x04, 0x68, 0x59, 0x96, 0x87, +0x48, 0xfc, 0xfc, 0xf9, 0xb3, 0xc5, 0xf0, 0x15, 0x00, 0xc0, 0x50, 0x3c, +0x2e, 0xee, 0x91, 0x85, 0x5b, 0x16, 0x70, 0x97, 0x2e, 0xf7, 0xf0, 0xc9, +0x9b, 0xf8, 0xf5, 0xeb, 0x57, 0xb4, 0xef, 0xe9, 0x3d, 0x11, 0x2e, 0x1d, +0x02, 0x00, 0x88, 0x29, 0x0e, 0xb2, 0x60, 0xe7, 0x12, 0x07, 0x35, 0xf9, +0x7e, 0x2a, 0x12, 0x78, 0x0f, 0x00, 0x00, 0x95, 0x21, 0x71, 0x7d, 0x0d, +0xfb, 0xe4, 0x14, 0x87, 0x50, 0x24, 0xae, 0x7e, 0x7f, 0x9f, 0x7b, 0xe0, +0x54, 0x36, 0x00, 0x40, 0x24, 0x1e, 0x79, 0x07, 0xc9, 0x05, 0xe4, 0xf6, +0x1e, 0xdc, 0x4a, 0xb8, 0xe9, 0xe2, 0x67, 0x20, 0xb4, 0x04, 0x00, 0x10, +0x89, 0x47, 0x39, 0xa8, 0x84, 0x77, 0x12, 0x25, 0x8b, 0x0f, 0x99, 0x78, +0x10, 0xf2, 0x59, 0x4e, 0x96, 0xd8, 0xd2, 0x2e, 0x1c, 0x00, 0x20, 0x12, +0xb3, 0xec, 0xd6, 0x65, 0x41, 0x8e, 0xb0, 0x73, 0x8f, 0x66, 0xf2, 0x79, +0x4e, 0x54, 0x51, 0x91, 0x77, 0x00, 0x00, 0x88, 0xc0, 0x4d, 0x72, 0x0e, +0xf6, 0x3c, 0x42, 0xa9, 0xdc, 0x83, 0xdb, 0xc8, 0x47, 0x88, 0x37, 0x73, +0xc0, 0x8b, 0x40, 0x1c, 0x00, 0x00, 0x22, 0x30, 0x69, 0x29, 0xab, 0x56, +0x0e, 0x1d, 0x5c, 0x8c, 0xb3, 0xe5, 0x23, 0x76, 0x7a, 0x34, 0x88, 0x03, +0x00, 0xc0, 0x59, 0x6f, 0xc1, 0xfd, 0x7b, 0xa2, 0xf8, 0xbd, 0x1b, 0xab, +0x2c, 0xbe, 0x39, 0xcf, 0x3a, 0xb8, 0x93, 0x67, 0x19, 0x9e, 0x85, 0x99, +0xfc, 0xcf, 0x32, 0xf1, 0x7a, 0x01, 0x00, 0x8e, 0x73, 0x77, 0x89, 0x5a, +0x74, 0xbb, 0x8c, 0xa1, 0xa6, 0x0d, 0x61, 0x58, 0x1c, 0xd5, 0x4a, 0x00, +0xbb, 0x76, 0x87, 0x77, 0x26, 0x0b, 0x18, 0x51, 0x98, 0x63, 0xdc, 0x11, +0x5d, 0x93, 0x27, 0xe1, 0x7c, 0x8f, 0x25, 0xef, 0x31, 0x70, 0xc6, 0x01, +0x86, 0x0f, 0x07, 0x3c, 0x26, 0x84, 0x36, 0x27, 0xdb, 0x32, 0xbb, 0x3b, +0xb4, 0xcd, 0xcc, 0x6c, 0x53, 0x33, 0x35, 0xf7, 0xb7, 0xa9, 0x99, 0x0a, +0xca, 0x8d, 0xc9, 0x96, 0xed, 0x9d, 0xde, 0x82, 0x67, 0xbe, 0x65, 0x47, +0xbf, 0xde, 0x23, 0x74, 0xf4, 0xac, 0xd1, 0x5d, 0x27, 0x02, 0xc1, 0x38, +0x85, 0x21, 0x85, 0xe0, 0x31, 0xb9, 0x75, 0xb1, 0xcf, 0x39, 0xc9, 0xc3, +0x0e, 0x99, 0xa1, 0xa8, 0xb8, 0xbf, 0x2d, 0x97, 0x11, 0x93, 0x63, 0x0b, +0xf7, 0xfb, 0x7b, 0xd5, 0x44, 0xab, 0xfe, 0x2a, 0xa6, 0xcf, 0x5d, 0xcd, +0xfe, 0xb9, 0x3e, 0x7f, 0xfb, 0x2e, 0xd6, 0x36, 0x05, 0xbd, 0x8a, 0x81, +0xe3, 0x7c, 0x03, 0x0c, 0xee, 0xfe, 0x2f, 0xe1, 0xce, 0xbf, 0x95, 0x5d, +0x9c, 0x8a, 0x89, 0xf1, 0x46, 0xa6, 0x15, 0x6f, 0xa4, 0x77, 0x21, 0xb1, +0x21, 0x3d, 0x15, 0xd0, 0x45, 0x93, 0xbe, 0x62, 0x52, 0x11, 0x24, 0xa6, +0x8b, 0xfe, 0xab, 0x77, 0xad, 0x22, 0xa1, 0xa5, 0x9d, 0x52, 0x55, 0xa4, +0x09, 0xe4, 0x51, 0x84, 0x40, 0x9f, 0xc1, 0xd6, 0x9f, 0xfb, 0x31, 0x07, +0xd0, 0xa7, 0x97, 0xd0, 0xfb, 0x44, 0x5f, 0xf3, 0x46, 0x4c, 0x48, 0xcb, +0x7a, 0x21, 0xcd, 0x86, 0xfb, 0x42, 0x11, 0x90, 0x85, 0x5c, 0x0f, 0x98, +0xc5, 0x5c, 0xd4, 0x55, 0x28, 0xf4, 0x6c, 0x42, 0xcd, 0x95, 0x46, 0x57, +0x7f, 0x4e, 0x5b, 0x55, 0xf5, 0xec, 0x14, 0x37, 0xf7, 0x56, 0x43, 0x4f, +0x4c, 0x3d, 0xc7, 0x84, 0xaf, 0x88, 0x48, 0xe0, 0x81, 0xe8, 0x25, 0x2f, +0xb5, 0x79, 0x79, 0x8f, 0x24, 0xaf, 0xb6, 0x7c, 0x50, 0x11, 0x58, 0xb3, +0x94, 0x0b, 0xb8, 0x3d, 0xc4, 0x56, 0xba, 0x47, 0x52, 0x8a, 0x9f, 0xcd, +0xb6, 0xf7, 0xd6, 0xff, 0x77, 0xe4, 0x21, 0xa0, 0x63, 0x66, 0xbf, 0xd3, +0x41, 0x10, 0x0e, 0x76, 0xdf, 0x5c, 0x4b, 0xaa, 0x07, 0x79, 0x90, 0x30, +0x9c, 0x75, 0x34, 0x1c, 0x64, 0xff, 0x5d, 0x18, 0x26, 0x7a, 0xf7, 0x0e, +0xd4, 0x33, 0xd8, 0x12, 0x04, 0x3d, 0x54, 0x96, 0xab, 0x25, 0xb6, 0xf5, +0x26, 0x7a, 0x11, 0x0a, 0x3d, 0xa0, 0x67, 0x5b, 0x7b, 0xe8, 0xcf, 0xe8, +0xb8, 0xdf, 0x01, 0x7a, 0xf4, 0x16, 0x10, 0x86, 0xfc, 0x9e, 0xc8, 0x9a, +0xa0, 0x58, 0x0b, 0x3d, 0x38, 0xfd, 0x77, 0xfa, 0xfb, 0xf6, 0x56, 0xb3, +0x67, 0xa2, 0xa0, 0x9e, 0x82, 0x88, 0x42, 0x29, 0xaf, 0xd0, 0x7a, 0x13, +0xad, 0x0a, 0x85, 0x3c, 0x3b, 0x2b, 0x0e, 0x62, 0xfa, 0x0e, 0x42, 0xc1, +0xd8, 0xb0, 0x89, 0xe5, 0x06, 0x10, 0x05, 0xac, 0x68, 0xa2, 0x54, 0x16, +0x63, 0x8d, 0x89, 0x97, 0xb8, 0x3c, 0x67, 0xaf, 0x37, 0x91, 0xf2, 0x4a, +0xd0, 0x14, 0x26, 0x9f, 0xdd, 0x8a, 0xb1, 0xe6, 0x1c, 0xac, 0xf8, 0xbd, +0x78, 0xd6, 0x54, 0x32, 0x41, 0x12, 0xc2, 0x50, 0xc3, 0x9a, 0x4d, 0x26, +0x9c, 0xb1, 0x66, 0x8f, 0xcb, 0xd1, 0x11, 0x05, 0xac, 0x86, 0x85, 0xb6, +0x25, 0x71, 0x08, 0x93, 0xee, 0x61, 0x9b, 0x0f, 0xeb, 0x55, 0x3c, 0xfb, +0xb9, 0xa8, 0x64, 0x82, 0x33, 0x8b, 0xfe, 0x14, 0x2e, 0xe2, 0x1a, 0x62, +0x58, 0x3b, 0x4c, 0x76, 0x76, 0x67, 0xc9, 0xc2, 0x84, 0x61, 0xe7, 0x5b, +0x77, 0x87, 0x61, 0xa5, 0xad, 0x9c, 0xc4, 0x33, 0x81, 0xa0, 0x92, 0x09, +0xd6, 0xb0, 0x22, 0xf0, 0xe1, 0x50, 0x19, 0x93, 0x0f, 0xc3, 0xea, 0xf7, +0x1e, 0xc2, 0x7c, 0x4e, 0x28, 0x02, 0x7b, 0xc3, 0x66, 0x54, 0x32, 0x21, +0x04, 0x33, 0x42, 0x80, 0x61, 0xfd, 0x85, 0xc4, 0x42, 0x91, 0xb0, 0xb9, +0x06, 0xeb, 0x61, 0xec, 0xc8, 0xf7, 0x50, 0xc9, 0x34, 0x50, 0x68, 0x68, +0xe1, 0xbc, 0x00, 0x86, 0xf5, 0x6f, 0x5a, 0x42, 0x1c, 0x7a, 0x12, 0x6b, +0x55, 0x4d, 0x2f, 0xbe, 0xd6, 0xc4, 0x12, 0xda, 0x97, 0x18, 0xbc, 0x87, +0x87, 0x5a, 0x6d, 0x31, 0xc1, 0x04, 0xc7, 0xb0, 0xb8, 0x09, 0x6b, 0x3d, +0x80, 0x68, 0x6d, 0xe7, 0x8d, 0x76, 0x5c, 0x0e, 0xd4, 0x83, 0x20, 0xb4, +0xee, 0x19, 0x68, 0xb9, 0x23, 0x02, 0x81, 0x61, 0xf5, 0x6c, 0xc2, 0x38, +0x30, 0xd7, 0x68, 0xee, 0xa0, 0xa7, 0x50, 0x91, 0xd6, 0xc1, 0x33, 0x79, +0x31, 0xac, 0xce, 0x93, 0xf7, 0x24, 0xab, 0xeb, 0xf7, 0x12, 0xba, 0x3c, +0x13, 0xa0, 0x75, 0xda, 0x4c, 0x44, 0x0c, 0xab, 0xd7, 0x38, 0x13, 0x51, +0xa1, 0x28, 0xf4, 0x9e, 0x50, 0x46, 0x1c, 0x30, 0x0c, 0x91, 0x00, 0x44, +0xe1, 0x53, 0x5c, 0xb3, 0xb5, 0xd3, 0xa9, 0x18, 0x86, 0x91, 0xb4, 0x2e, +0x95, 0x53, 0x58, 0x46, 0x4a, 0xce, 0x6a, 0x8f, 0x18, 0x26, 0x1b, 0x86, +0xe1, 0x49, 0xc0, 0x86, 0x28, 0x8c, 0xd8, 0x67, 0x48, 0x2f, 0x80, 0x61, +0xa2, 0x61, 0x58, 0xd3, 0x46, 0x23, 0xbf, 0x54, 0xa2, 0x30, 0x6a, 0x29, +0x27, 0x9e, 0x03, 0x86, 0x21, 0x10, 0xf0, 0x31, 0xaf, 0x40, 0x47, 0x52, +0x3c, 0x07, 0x0c, 0xeb, 0xcd, 0x26, 0x96, 0xf7, 0xf3, 0x0c, 0x7d, 0x05, +0xa6, 0xbd, 0x2f, 0xd9, 0x99, 0x43, 0x70, 0x4c, 0x2a, 0xac, 0x97, 0xf1, +0xcd, 0x73, 0x40, 0x20, 0xc8, 0x2b, 0x3c, 0x99, 0x20, 0x2b, 0x77, 0x1d, +0xdb, 0xbb, 0x1e, 0x94, 0x85, 0x43, 0x70, 0x18, 0x86, 0x40, 0xe0, 0x2d, +0x74, 0xb8, 0xab, 0x78, 0x72, 0xe9, 0xfd, 0x9e, 0xa3, 0xf7, 0xb3, 0x36, +0x07, 0x63, 0x32, 0x61, 0x58, 0x77, 0x1e, 0x14, 0xed, 0x37, 0x5e, 0xe4, +0x16, 0xe6, 0xde, 0xbc, 0x05, 0x23, 0x06, 0x2a, 0x04, 0x67, 0x8f, 0xd7, +0x2f, 0x7a, 0x85, 0x24, 0xee, 0x38, 0xd6, 0xa3, 0xb5, 0x76, 0x3f, 0x75, +0x64, 0xe3, 0x2c, 0xc4, 0x96, 0xb7, 0xe0, 0x3a, 0x39, 0xb3, 0x20, 0x3f, +0xc3, 0x4a, 0x88, 0x28, 0xca, 0x33, 0xd2, 0x3b, 0x6f, 0x07, 0x9f, 0x44, +0x58, 0xc7, 0x3b, 0xe8, 0x51, 0xc7, 0x36, 0x7d, 0x99, 0x9e, 0xe4, 0x17, +0x3a, 0x0b, 0x15, 0xa5, 0x78, 0xc9, 0x77, 0xbd, 0xd1, 0x8a, 0xd0, 0x12, +0x46, 0xa2, 0x9a, 0xdc, 0xc3, 0x10, 0xc2, 0xd0, 0xe2, 0x60, 0x30, 0x55, +0x44, 0x4b, 0x2e, 0xc5, 0x97, 0xef, 0xa7, 0xbd, 0xe6, 0x09, 0x2d, 0x61, +0x18, 0xa1, 0x25, 0x84, 0xa1, 0xce, 0xb0, 0xd1, 0xec, 0xf2, 0xbb, 0x81, +0x33, 0xa1, 0x25, 0x8c, 0x1c, 0x04, 0xed, 0x35, 0x7a, 0x4f, 0x3e, 0x37, +0x25, 0x0c, 0xc6, 0x53, 0x28, 0x21, 0x0a, 0xef, 0x82, 0x2a, 0x9f, 0x43, +0xef, 0xba, 0xc5, 0x7b, 0xc0, 0x7a, 0x17, 0x87, 0x91, 0x4a, 0xb7, 0xfd, +0x7c, 0xbe, 0x21, 0x0c, 0x8d, 0x2c, 0x6c, 0x26, 0x74, 0x34, 0x55, 0xf2, +0xe2, 0x26, 0xbd, 0xeb, 0x96, 0xdc, 0x03, 0xd6, 0xbb, 0xc9, 0x18, 0x1f, +0xc5, 0x83, 0xf0, 0x6b, 0xcd, 0xb0, 0x25, 0xad, 0x4d, 0x9c, 0x61, 0x08, +0xf2, 0x09, 0x35, 0xbe, 0xac, 0xf9, 0xc0, 0x25, 0xe8, 0x18, 0xd6, 0xf4, +0x6e, 0x5a, 0xca, 0xb7, 0x49, 0x4a, 0x77, 0x2e, 0x0c, 0xb5, 0x9f, 0x61, +0x08, 0xf2, 0x09, 0x55, 0x2b, 0xb8, 0xe6, 0x1e, 0xf0, 0x1e, 0xb0, 0x11, +0xbc, 0x87, 0x11, 0x04, 0xc2, 0x6f, 0xf4, 0x26, 0x84, 0xa1, 0xce, 0xd0, +0xd1, 0xbd, 0xa1, 0x98, 0xdf, 0x4d, 0x4b, 0x5b, 0x49, 0x4e, 0x63, 0xbd, +0x2f, 0x9a, 0x23, 0x6c, 0x84, 0x46, 0x0c, 0x2b, 0xdd, 0x6b, 0x0c, 0x25, +0xb5, 0xe4, 0x25, 0x3c, 0x0b, 0x2f, 0xc9, 0x8e, 0x4a, 0x26, 0x0e, 0x8b, +0x08, 0xd6, 0xb3, 0xe9, 0x38, 0xcf, 0xb1, 0x8e, 0xe8, 0x61, 0x3c, 0xbb, +0xe9, 0x92, 0xb5, 0x42, 0x4d, 0x1b, 0x62, 0x26, 0x10, 0x86, 0x92, 0xc5, +0x2e, 0x45, 0xa8, 0x2e, 0xf9, 0xdc, 0x81, 0x28, 0x7c, 0x10, 0x08, 0xaa, +0x97, 0xb0, 0xde, 0x4d, 0xc3, 0xa8, 0xa9, 0xc3, 0x4b, 0x22, 0x08, 0x7a, +0x1d, 0xaf, 0x17, 0x87, 0x67, 0x9d, 0x0e, 0x6e, 0xfe, 0xf7, 0x27, 0x6f, +0xb3, 0xb1, 0x45, 0xcd, 0x0a, 0x8b, 0x35, 0xf3, 0x77, 0xa7, 0x11, 0x13, +0xd1, 0x55, 0x85, 0x93, 0xfc, 0xe2, 0xb9, 0x74, 0xf8, 0x22, 0x10, 0x08, +0xac, 0xfb, 0xd0, 0x92, 0x8e, 0xf1, 0x54, 0x61, 0x54, 0x15, 0x06, 0x0d, +0x61, 0xf9, 0x05, 0x9c, 0x86, 0x78, 0xa9, 0xbc, 0x86, 0xca, 0x44, 0x61, +0xea, 0xd5, 0x6d, 0x93, 0x81, 0x2c, 0x83, 0x5a, 0x26, 0x10, 0x8b, 0x09, +0xd6, 0x73, 0x68, 0x29, 0x95, 0xf7, 0xa0, 0xde, 0x89, 0xcc, 0x21, 0xe3, +0x35, 0x40, 0x8a, 0x84, 0x69, 0x0d, 0x5e, 0x43, 0xc1, 0xd3, 0xcc, 0xd9, +0x91, 0xe7, 0x8d, 0x40, 0x60, 0xbd, 0x87, 0x96, 0xc4, 0x62, 0x1f, 0x8e, +0x93, 0x0d, 0xa4, 0x9e, 0x1f, 0x12, 0xf1, 0xf1, 0x6b, 0xd7, 0xc4, 0x32, +0x9e, 0x28, 0xa4, 0x54, 0x32, 0xc4, 0x51, 0xf9, 0x39, 0x05, 0x3c, 0x08, +0x0c, 0x3b, 0x11, 0xf6, 0x51, 0x71, 0x88, 0xed, 0x3d, 0xc8, 0xd7, 0xd6, +0xb0, 0x95, 0x08, 0x8f, 0xdf, 0x54, 0xd2, 0x25, 0x35, 0x95, 0x38, 0x14, +0x16, 0x85, 0x61, 0x55, 0x5f, 0x27, 0x11, 0x02, 0x81, 0xf5, 0x1a, 0x5a, +0x8a, 0x9d, 0x7b, 0x58, 0x09, 0x29, 0xcd, 0x2c, 0xe1, 0x1d, 0x85, 0x95, +0x46, 0x0a, 0x21, 0xbd, 0xe0, 0xde, 0xb3, 0x40, 0x90, 0x74, 0x1f, 0xfb, +0x40, 0x5c, 0x8a, 0xd0, 0x92, 0xad, 0x86, 0x22, 0x11, 0x9d, 0x49, 0x20, +0x32, 0x0b, 0x03, 0x31, 0x42, 0xe3, 0xb9, 0xe9, 0x44, 0xea, 0x4d, 0x20, +0x44, 0x1c, 0xb8, 0x4b, 0x9b, 0xbc, 0x43, 0xac, 0xd0, 0x92, 0xcd, 0x37, +0x98, 0x2a, 0x25, 0xc8, 0x21, 0x10, 0x29, 0x77, 0x7a, 0xa3, 0xe6, 0x16, +0xf6, 0xe6, 0x1f, 0x6c, 0x92, 0xad, 0xb7, 0xf8, 0xf3, 0x60, 0x3d, 0x77, +0xb0, 0x84, 0x79, 0x07, 0x0d, 0x57, 0xf9, 0x4d, 0x07, 0x21, 0xa5, 0xd6, +0x3d, 0x88, 0x51, 0x4f, 0x15, 0x1e, 0x60, 0xb1, 0xae, 0x38, 0x02, 0x81, +0xf5, 0xe0, 0x35, 0x6a, 0xe2, 0xd8, 0xe4, 0x07, 0xa2, 0x88, 0x03, 0x25, +0xac, 0x05, 0x89, 0x99, 0x83, 0xa0, 0xd4, 0x6c, 0x17, 0x73, 0x18, 0xab, +0xed, 0xad, 0x3f, 0x0d, 0x02, 0x41, 0x52, 0x3a, 0xb6, 0x38, 0x10, 0x56, +0x2a, 0x98, 0x2c, 0xbd, 0xba, 0x73, 0x20, 0xbf, 0xb0, 0x3f, 0xef, 0x60, +0x43, 0x7a, 0x2a, 0x10, 0xbd, 0xc5, 0xeb, 0xe5, 0xe7, 0x41, 0x20, 0x38, +0xef, 0x70, 0xc5, 0x64, 0x6e, 0xe0, 0x39, 0x54, 0xb4, 0xab, 0x3d, 0x92, +0x8b, 0xa8, 0xe4, 0x26, 0xb6, 0xe6, 0x9f, 0xb1, 0xee, 0xba, 0x7a, 0xeb, +0xe4, 0xaa, 0x93, 0x9b, 0xc5, 0x33, 0x5d, 0x38, 0x47, 0x9e, 0x71, 0x0d, +0x95, 0x62, 0xb6, 0x62, 0x29, 0xd6, 0xa6, 0x40, 0xbf, 0x26, 0x65, 0xac, +0xf5, 0x79, 0x12, 0x8b, 0xed, 0x76, 0x68, 0x2d, 0x68, 0x92, 0x87, 0x28, +0x9c, 0xc8, 0x39, 0x84, 0x96, 0xba, 0x47, 0x4d, 0xc9, 0x70, 0x03, 0x1e, +0x44, 0xda, 0xe7, 0x5b, 0xda, 0xeb, 0xd4, 0xcb, 0x7f, 0x54, 0x1c, 0x64, +0x2c, 0xc7, 0x10, 0x2c, 0xf5, 0x46, 0xfc, 0xcf, 0x87, 0xe7, 0x00, 0x63, +0x8a, 0x83, 0x15, 0x88, 0xde, 0xce, 0x0c, 0xc8, 0xcf, 0x85, 0x40, 0xf4, +0x2b, 0xbe, 0xf6, 0x24, 0x73, 0xcc, 0xbc, 0x83, 0x56, 0x41, 0x21, 0x0e, +0x30, 0x84, 0x47, 0xe6, 0xbd, 0xae, 0x97, 0x55, 0x1f, 0xbd, 0x85, 0x3f, +0xb8, 0x21, 0x2f, 0x9d, 0x38, 0x94, 0x0e, 0xdd, 0xd9, 0x52, 0x56, 0x0d, +0x2b, 0x21, 0x0e, 0x00, 0x07, 0xbd, 0x86, 0x57, 0x5e, 0x81, 0x2e, 0xa4, +0xbd, 0xc5, 0xea, 0xb9, 0x21, 0x2f, 0x5d, 0x22, 0x38, 0x56, 0x18, 0x27, +0x46, 0xbe, 0x41, 0x3e, 0x4b, 0xac, 0x30, 0x97, 0x8e, 0x19, 0x73, 0x42, +0x1a, 0xa0, 0x4b, 0xe6, 0xbd, 0x65, 0xc3, 0xbd, 0xb6, 0xd9, 0xd0, 0x45, +0x84, 0x56, 0x1b, 0xf1, 0xab, 0x84, 0x4a, 0x89, 0x6e, 0x18, 0x52, 0x8a, +0x79, 0xce, 0xc1, 0xce, 0x03, 0x3f, 0x66, 0xc8, 0x6f, 0x42, 0x77, 0x4c, +0xcf, 0xc2, 0x49, 0xaf, 0x76, 0x4d, 0xbd, 0xe5, 0x1f, 0xa8, 0x60, 0x8a, +0x1f, 0xb2, 0x2b, 0x35, 0x4e, 0xac, 0xd7, 0x10, 0x3b, 0x74, 0x68, 0x5b, +0xcd, 0x98, 0x6b, 0x40, 0x01, 0xfa, 0xc9, 0x33, 0xb8, 0x93, 0x17, 0x2c, +0xa9, 0x40, 0xf4, 0x14, 0xab, 0xef, 0xf1, 0x67, 0xaa, 0x21, 0xef, 0x50, +0xea, 0xac, 0x4c, 0xca, 0x90, 0x92, 0x7a, 0x24, 0xb6, 0x5c, 0xd7, 0x7b, +0xdf, 0x00, 0xe3, 0x0a, 0x43, 0x18, 0x36, 0xe8, 0x69, 0x31, 0x0d, 0xea, +0xd7, 0x59, 0xe0, 0x1b, 0x16, 0xdc, 0xf0, 0x7c, 0x43, 0xac, 0x77, 0xaa, +0xb9, 0x94, 0xb5, 0xaf, 0x49, 0xfe, 0x01, 0x86, 0x0b, 0x25, 0xbd, 0x9a, +0x80, 0x3d, 0x09, 0x04, 0xe1, 0xa5, 0xf6, 0xab, 0x96, 0xec, 0xfd, 0xce, +0x31, 0x43, 0x5b, 0xf2, 0x75, 0x5f, 0x8d, 0x79, 0x04, 0x02, 0x5a, 0xe4, +0x16, 0x53, 0x18, 0x6a, 0x08, 0x1d, 0xb8, 0x84, 0x89, 0x54, 0xda, 0x7c, +0xc7, 0x15, 0xdc, 0x9c, 0xde, 0x58, 0x98, 0x8c, 0x8e, 0xb5, 0x79, 0xb1, +0x97, 0xfc, 0x3c, 0x1b, 0x1f, 0x08, 0x04, 0xb4, 0xc6, 0x92, 0xaa, 0x1a, +0xa7, 0xa7, 0x53, 0xd4, 0xbd, 0x26, 0xdc, 0x4b, 0x0b, 0x6e, 0xce, 0xe7, +0x69, 0xc5, 0x21, 0x76, 0x37, 0xd6, 0xbd, 0x62, 0x83, 0x40, 0x40, 0x53, +0xe1, 0xa4, 0xd4, 0xbb, 0xc3, 0x1e, 0xca, 0x41, 0xed, 0x81, 0x3f, 0x4a, +0x5b, 0xdb, 0x6d, 0xa7, 0x11, 0x5b, 0x1c, 0x54, 0x70, 0x8e, 0x7c, 0x3d, +0x92, 0xd4, 0xd0, 0x94, 0xf7, 0x90, 0x7a, 0xc7, 0xdd, 0x43, 0xbc, 0xbe, +0xb7, 0x50, 0x59, 0x4d, 0xcf, 0x35, 0x87, 0xe0, 0xda, 0x9e, 0x4a, 0x31, +0xc4, 0x41, 0x1b, 0x09, 0x9e, 0xa9, 0x7a, 0xe2, 0x1c, 0x04, 0x34, 0x43, +0xca, 0xbb, 0xba, 0x7b, 0xb8, 0x28, 0x48, 0xaf, 0x15, 0x25, 0xb4, 0x94, +0x66, 0x03, 0x91, 0xab, 0x78, 0x21, 0x96, 0x38, 0xd8, 0xf1, 0x70, 0xf6, +0x6b, 0x21, 0x10, 0xd0, 0x0c, 0x29, 0x77, 0x6f, 0x3d, 0xdc, 0x03, 0x61, +0x17, 0x03, 0x42, 0x4b, 0xf1, 0xc7, 0x47, 0x8e, 0xb1, 0x11, 0x1e, 0x54, +0xbb, 0x22, 0x66, 0x36, 0xb1, 0x7d, 0x71, 0x3c, 0x70, 0x3d, 0x31, 0x54, +0x4f, 0xd2, 0xbb, 0xba, 0x75, 0xd7, 0xd6, 0xea, 0xc2, 0x7a, 0x75, 0xa7, +0x88, 0xbd, 0xce, 0x07, 0xa4, 0x16, 0x08, 0x7b, 0xc9, 0xcf, 0xd9, 0xdd, +0xbe, 0x26, 0xd2, 0x35, 0x5f, 0x12, 0x69, 0x3c, 0x4f, 0x2c, 0x3f, 0x50, +0x3b, 0x77, 0x97, 0x30, 0x34, 0xd3, 0x72, 0xfe, 0x01, 0xcf, 0x21, 0x4f, +0xd2, 0x3f, 0xb5, 0xf0, 0xda, 0x93, 0xcc, 0x67, 0x3e, 0xa3, 0x7c, 0xbe, +0x44, 0x9f, 0x91, 0x0b, 0x82, 0xa0, 0x7a, 0x26, 0x97, 0x38, 0x41, 0xdd, +0x62, 0xdc, 0x3e, 0x66, 0x32, 0x13, 0x2b, 0x77, 0x9f, 0x77, 0xe5, 0x9b, +0x14, 0x5a, 0x7d, 0x43, 0xf5, 0x24, 0xab, 0x60, 0x6a, 0xb5, 0xc5, 0x86, +0x8a, 0x43, 0xcc, 0xb6, 0x0b, 0x58, 0x99, 0xf3, 0x0f, 0x7b, 0x0f, 0x35, +0xfa, 0x42, 0x8d, 0x25, 0xa7, 0xa7, 0x48, 0xa9, 0x2b, 0x54, 0x4f, 0x8e, +0x0a, 0xa6, 0x56, 0x16, 0x59, 0xed, 0x9d, 0x13, 0x24, 0x20, 0x67, 0xef, +0x65, 0x2d, 0x29, 0x9f, 0xd5, 0xa8, 0x02, 0x91, 0x7a, 0xf3, 0xa0, 0x2d, +0x3c, 0xfc, 0xbb, 0x5c, 0xfc, 0x01, 0xb5, 0xc5, 0xbc, 0xd7, 0xbb, 0xfb, +0x98, 0x2c, 0x9e, 0x73, 0x86, 0xd8, 0x1c, 0x95, 0x4c, 0x50, 0x31, 0x49, +0x13, 0xd4, 0x2d, 0xf5, 0x2b, 0x0a, 0x43, 0x4a, 0x7e, 0x21, 0xb9, 0x6f, +0x84, 0xe4, 0x66, 0xbd, 0xcf, 0x9c, 0x85, 0xfe, 0xda, 0x06, 0x22, 0xa5, +0x40, 0x5c, 0xb8, 0xb9, 0x6d, 0xc9, 0xf8, 0x1c, 0xa8, 0x64, 0x82, 0xf1, +0xf2, 0x0f, 0xad, 0x84, 0x97, 0xc2, 0xc3, 0x53, 0xf2, 0xff, 0xde, 0x53, +0xb8, 0x1d, 0x78, 0x86, 0x8b, 0xee, 0x4e, 0xe5, 0xdf, 0x9a, 0x7e, 0xff, +0x55, 0xfe, 0xbc, 0x5b, 0x9f, 0x4d, 0xff, 0x4c, 0x4d, 0x7e, 0x16, 0xf9, +0x99, 0x52, 0x98, 0x7c, 0x6d, 0x79, 0xee, 0x29, 0xc7, 0x47, 0xe0, 0x3d, +0x1c, 0xd9, 0xa9, 0xdf, 0x32, 0x7a, 0x8b, 0x13, 0xcb, 0x10, 0xd4, 0xca, +0xec, 0x12, 0xef, 0xc8, 0x6b, 0x3d, 0xff, 0xa0, 0x35, 0xed, 0x2b, 0x6d, +0x17, 0x96, 0x48, 0xbb, 0xba, 0x9b, 0x09, 0x5f, 0xd4, 0x64, 0xcf, 0x3e, +0x5b, 0xb6, 0x70, 0x87, 0x2c, 0xc0, 0x29, 0x4b, 0x5c, 0x23, 0xdc, 0xfb, +0x7c, 0xcf, 0x24, 0x12, 0x24, 0xaa, 0xa1, 0x4e, 0x62, 0x77, 0x6d, 0x75, +0xdb, 0x57, 0x2b, 0x56, 0x57, 0x39, 0x13, 0xde, 0x1c, 0xe6, 0x9f, 0x05, +0xbb, 0xb9, 0x8c, 0xa1, 0xcd, 0x94, 0xf9, 0xa9, 0x0b, 0xde, 0x43, 0x16, +0x0f, 0x3b, 0xc8, 0x43, 0x00, 0x8c, 0x93, 0x7f, 0xa8, 0xb1, 0xbd, 0x86, +0x26, 0x44, 0xad, 0x30, 0x98, 0x26, 0x71, 0xd4, 0xa3, 0xe7, 0xe5, 0xae, +0x9b, 0x88, 0x14, 0x02, 0x61, 0xbd, 0x87, 0xab, 0x5d, 0x53, 0x53, 0x6d, +0xa2, 0x1c, 0x89, 0x6a, 0x18, 0x55, 0x20, 0x34, 0x6c, 0x53, 0x43, 0x78, +0x69, 0xcd, 0x63, 0xd0, 0xf2, 0xd5, 0x27, 0x89, 0x68, 0x48, 0x3c, 0xf6, +0x52, 0x0a, 0x44, 0x24, 0xef, 0xe1, 0x5d, 0xcc, 0x1c, 0x79, 0x08, 0x18, +0x90, 0x24, 0xee, 0xb3, 0x4e, 0xfc, 0xd2, 0xed, 0x35, 0x6c, 0x43, 0xb5, +0x95, 0xbb, 0x86, 0x17, 0x76, 0x6d, 0x7d, 0x7a, 0x10, 0xc1, 0xb9, 0x87, +0x58, 0x9e, 0x61, 0xd2, 0xaa, 0x26, 0xee, 0x86, 0x80, 0xea, 0x48, 0xe5, +0x3a, 0xdb, 0x43, 0x66, 0xae, 0x82, 0xf3, 0x0c, 0x56, 0x18, 0xc8, 0x33, +0xd4, 0xb3, 0x39, 0xd1, 0x85, 0x3c, 0xf6, 0x26, 0x42, 0xef, 0x80, 0x8e, +0x7c, 0x08, 0x2d, 0x69, 0x39, 0x38, 0x61, 0x26, 0xa8, 0x6e, 0x07, 0x97, +0x6a, 0xa0, 0x5f, 0xe9, 0x7b, 0x13, 0x33, 0x9c, 0x24, 0x9f, 0x43, 0x3e, +0x83, 0xfc, 0x9e, 0x5f, 0x2c, 0x10, 0x86, 0xce, 0x05, 0x22, 0xf0, 0x4a, +0x62, 0xe7, 0x95, 0xa6, 0xc4, 0xe3, 0x97, 0x3c, 0x18, 0xf4, 0xed, 0x3d, +0xd8, 0x24, 0x70, 0xa9, 0xfb, 0x85, 0xd5, 0x5b, 0xf0, 0xa2, 0x30, 0x3b, +0x72, 0x0c, 0xd5, 0x0a, 0x44, 0xec, 0x43, 0x94, 0x7a, 0xae, 0x22, 0x51, +0xc8, 0x26, 0xa9, 0x17, 0x41, 0xdb, 0x0d, 0xa8, 0x85, 0x68, 0x03, 0x5d, +0xdb, 0x17, 0xc8, 0x84, 0xd7, 0x83, 0x4f, 0x39, 0xcb, 0x5b, 0xd7, 0x2e, +0x9e, 0x37, 0xde, 0x02, 0x2e, 0x7b, 0xe5, 0x02, 0x11, 0x33, 0x0c, 0xa9, +0xde, 0xe3, 0xc1, 0x43, 0x8e, 0x47, 0x49, 0xdd, 0x86, 0x83, 0xcd, 0x0c, +0x74, 0x13, 0x5e, 0xfa, 0x90, 0xe8, 0xd5, 0x83, 0x4f, 0xba, 0x58, 0xa7, +0xac, 0x60, 0x0a, 0x4f, 0x3f, 0x1b, 0x61, 0x20, 0xf9, 0xdc, 0x06, 0x73, +0x6c, 0x81, 0x30, 0x17, 0x0f, 0xa5, 0x0c, 0xd5, 0xdc, 0x12, 0x6f, 0x7c, +0x38, 0x34, 0x07, 0xe5, 0x27, 0xa7, 0x4b, 0x50, 0x96, 0x17, 0x0a, 0x44, +0xaa, 0x1c, 0x84, 0xbd, 0x20, 0xde, 0x84, 0x92, 0x10, 0x86, 0xb6, 0x58, +0xf4, 0x14, 0x7b, 0xcc, 0x0d, 0x43, 0xa6, 0x64, 0x6f, 0x32, 0x2f, 0x82, +0x64, 0x35, 0xf4, 0x10, 0x5e, 0x5a, 0xdd, 0xe5, 0x48, 0xdc, 0xd7, 0x9e, +0x37, 0x88, 0x5d, 0xc5, 0xa4, 0x31, 0xeb, 0x95, 0x1c, 0x03, 0x13, 0xaa, +0x41, 0x81, 0xd0, 0xdb, 0xd9, 0x22, 0x7b, 0x0f, 0x4b, 0x23, 0x73, 0x08, +0x2f, 0x02, 0xfa, 0xf3, 0x1e, 0x5e, 0xb4, 0x05, 0x98, 0xed, 0xb9, 0x83, +0x58, 0x79, 0x08, 0x9b, 0x67, 0x30, 0xa1, 0x24, 0x2a, 0x3e, 0x3a, 0x10, +0x88, 0x18, 0x5e, 0x66, 0x66, 0xef, 0x21, 0xb9, 0x17, 0xc1, 0x99, 0x08, +0x28, 0xc6, 0xd5, 0xe6, 0x63, 0xaf, 0x06, 0xaf, 0x4d, 0x54, 0xc7, 0xc8, +0x43, 0xd8, 0xb2, 0x59, 0x0e, 0xb8, 0x21, 0x10, 0x5b, 0x9e, 0x65, 0x46, +0xef, 0x21, 0xda, 0x5c, 0x22, 0xcc, 0x04, 0xb5, 0x71, 0x8f, 0x30, 0x70, +0xa7, 0x57, 0x13, 0xdf, 0x7a, 0x11, 0x31, 0x16, 0x00, 0x15, 0x1c, 0x9a, +0x9a, 0x21, 0x10, 0x5b, 0x02, 0x51, 0x68, 0x51, 0x4d, 0xd9, 0x82, 0x03, +0x0f, 0x19, 0xda, 0x0a, 0x2f, 0xed, 0xac, 0xd3, 0xbe, 0xd9, 0x5d, 0x7f, +0x8c, 0x18, 0xb3, 0x26, 0x33, 0xa9, 0x13, 0x47, 0x20, 0x9e, 0x6c, 0x5c, +0x8a, 0x2c, 0xa8, 0xa9, 0xce, 0x13, 0x11, 0x66, 0x82, 0xa6, 0xbc, 0x07, +0x77, 0x20, 0x79, 0x26, 0x83, 0x3b, 0xe6, 0x81, 0x39, 0x04, 0xa2, 0x3f, +0xb4, 0xa0, 0x21, 0x46, 0x29, 0x74, 0xe1, 0xc5, 0x34, 0x49, 0xc2, 0x9a, +0xb1, 0x0e, 0x4d, 0xed, 0x74, 0x0e, 0xba, 0xf0, 0xf7, 0x98, 0x5e, 0x84, +0x56, 0x2f, 0xb1, 0xab, 0xea, 0x07, 0x2d, 0x89, 0xbe, 0xba, 0x79, 0xa8, +0x24, 0x5e, 0x9f, 0x2a, 0x61, 0x3d, 0x31, 0x52, 0x20, 0x07, 0x93, 0xcb, +0x5f, 0x7a, 0xf7, 0x21, 0x17, 0x71, 0x65, 0x97, 0x65, 0x0e, 0x54, 0x51, +0xfe, 0x87, 0x40, 0x54, 0x19, 0xab, 0x4f, 0x91, 0xb0, 0x66, 0x43, 0x04, +0x59, 0x5c, 0xe0, 0x48, 0x83, 0x77, 0x3a, 0x33, 0x69, 0x34, 0xc1, 0x7c, +0x25, 0xd6, 0x6c, 0xaa, 0x54, 0x68, 0x43, 0xd0, 0xd1, 0x98, 0xbc, 0x5a, +0x06, 0x5d, 0x59, 0xb5, 0x4f, 0x8c, 0x4d, 0x18, 0xd5, 0x4c, 0xd0, 0x56, +0x68, 0xe9, 0xe2, 0x4e, 0xe6, 0xfd, 0x5c, 0xc4, 0x95, 0x13, 0xb3, 0xb2, +0xcb, 0xf4, 0x3b, 0x4d, 0x26, 0x4b, 0x27, 0x02, 0xa1, 0x67, 0x17, 0x7a, +0x0a, 0xc1, 0x24, 0x4a, 0x58, 0x53, 0xcd, 0x04, 0xc9, 0x98, 0x0b, 0x0f, +0xd2, 0x9b, 0x6d, 0xbf, 0x71, 0x25, 0x9c, 0xc0, 0x6e, 0xaa, 0x2b, 0x26, +0x6d, 0xac, 0xd7, 0xd9, 0x78, 0xb8, 0xc7, 0x4e, 0x58, 0x13, 0x66, 0x82, +0xaa, 0x5d, 0xde, 0x08, 0x13, 0xf1, 0xdd, 0x8b, 0xb8, 0x12, 0x66, 0xa2, +0xaa, 0xa3, 0x2b, 0x16, 0xd3, 0x1a, 0xa3, 0xab, 0x85, 0x33, 0xb6, 0x17, +0xc1, 0xc6, 0x08, 0x6a, 0xdf, 0xc9, 0x5c, 0x4e, 0x0c, 0xab, 0x17, 0x71, +0x25, 0xcc, 0x84, 0x40, 0xf4, 0x43, 0xa4, 0x12, 0xd7, 0xa9, 0xd2, 0x1f, +0x2f, 0x45, 0xd9, 0x2b, 0x61, 0x26, 0x88, 0x47, 0xac, 0x8a, 0x8a, 0x88, +0xbb, 0x97, 0x77, 0x2f, 0xe2, 0x6c, 0x98, 0x09, 0x81, 0xe8, 0x86, 0xf7, +0x83, 0x94, 0x67, 0xc7, 0x42, 0x03, 0xbb, 0xea, 0xa8, 0x65, 0xaf, 0x8c, +0x7d, 0x88, 0xea, 0xbe, 0x57, 0xb8, 0x73, 0x79, 0xe4, 0x22, 0xae, 0x84, +0x99, 0x98, 0x24, 0x7d, 0x79, 0xb7, 0x17, 0x4b, 0x5c, 0xab, 0xdf, 0x51, +0x27, 0x28, 0x7b, 0xa5, 0x82, 0x0f, 0xea, 0x11, 0x87, 0x04, 0x31, 0xde, +0x4b, 0xfd, 0xff, 0x11, 0x88, 0x6e, 0xb8, 0x94, 0xa0, 0x6e, 0x28, 0x26, +0x3f, 0x39, 0x92, 0xd5, 0xd0, 0xa3, 0x38, 0x24, 0x9a, 0x84, 0x53, 0x70, +0xa1, 0x3c, 0x02, 0x31, 0xa8, 0x40, 0x98, 0x73, 0x2d, 0x5d, 0x9f, 0x2e, +0x8e, 0x99, 0xb0, 0xa6, 0x51, 0x25, 0xd4, 0x24, 0x0e, 0x29, 0x26, 0xe1, +0xa5, 0x30, 0x13, 0x13, 0xa4, 0x9f, 0xb1, 0x3a, 0x50, 0x1e, 0xea, 0x16, +0x39, 0xd4, 0x34, 0x31, 0x7c, 0xe0, 0xd0, 0x00, 0x4c, 0x70, 0x38, 0x27, +0x65, 0x3b, 0x8b, 0xd3, 0x61, 0x26, 0xca, 0xfd, 0xfa, 0x18, 0xaf, 0x17, +0x2b, 0x7c, 0x5a, 0x5c, 0x20, 0xa3, 0x85, 0x9a, 0x08, 0x33, 0xc1, 0x5e, +0x24, 0x61, 0xb5, 0xc4, 0x4e, 0x84, 0x65, 0x58, 0x84, 0xef, 0x67, 0xc3, +0x4c, 0x08, 0x44, 0x17, 0x9c, 0xae, 0xee, 0x69, 0x7c, 0x71, 0x9c, 0x1d, +0x61, 0x26, 0xc8, 0x31, 0xd0, 0x64, 0xa2, 0x24, 0xbc, 0x0f, 0x37, 0xf9, +0x0e, 0x4d, 0x6b, 0xe0, 0x8f, 0x26, 0x29, 0xfd, 0xcf, 0x4c, 0x25, 0x47, +0xc3, 0x9b, 0x9a, 0xb3, 0xe3, 0xb6, 0x87, 0x77, 0x1f, 0xd1, 0xd3, 0xe7, +0x4c, 0x04, 0x7c, 0x9e, 0x5c, 0xa9, 0xae, 0x37, 0xcc, 0x14, 0x5a, 0xfa, +0xe0, 0x72, 0xab, 0x17, 0x71, 0x62, 0xc1, 0x98, 0x18, 0x0a, 0x6d, 0x6e, +0x6c, 0x2e, 0x6e, 0x6a, 0x7a, 0x58, 0x14, 0xa3, 0xdc, 0x3e, 0x47, 0xb1, +0x06, 0x44, 0xdb, 0x79, 0x55, 0x1a, 0xbe, 0x79, 0x4f, 0x56, 0x9f, 0xa8, +0x64, 0xa1, 0xdd, 0x77, 0x9d, 0xdc, 0xfc, 0x02, 0x38, 0xf9, 0xc5, 0x7c, +0xf6, 0xef, 0xea, 0x72, 0x18, 0xb4, 0xa7, 0x05, 0x11, 0x2f, 0x02, 0x6a, +0x1e, 0x54, 0x35, 0xed, 0xcc, 0x67, 0xbd, 0x04, 0x88, 0xdd, 0x53, 0x73, +0xa8, 0x08, 0x2c, 0x32, 0x36, 0xe5, 0x9d, 0xa4, 0xda, 0xc0, 0x74, 0x18, +0x56, 0x8c, 0xd2, 0x86, 0x83, 0x79, 0x00, 0xef, 0x0b, 0x69, 0x6a, 0x71, +0x28, 0x94, 0xfc, 0xbb, 0xd2, 0x6e, 0x81, 0x30, 0x53, 0xfe, 0xd0, 0xc8, +0xe4, 0x12, 0x14, 0x45, 0x0c, 0xba, 0x53, 0x8e, 0x35, 0xa7, 0x99, 0x07, +0x78, 0x0f, 0x69, 0xbd, 0x87, 0xc2, 0x95, 0x21, 0x8f, 0x92, 0xd7, 0xa3, +0x67, 0x22, 0xd8, 0x3d, 0x65, 0x0d, 0x1b, 0x2d, 0x2e, 0xaf, 0x20, 0x8c, +0x12, 0x4e, 0xbc, 0xfc, 0x5c, 0xa9, 0xea, 0x83, 0x29, 0xe5, 0x04, 0xf4, +0x0b, 0x6d, 0xc9, 0x01, 0xf6, 0xee, 0x45, 0x9c, 0x70, 0xbb, 0x89, 0xc1, +0x26, 0xde, 0xe5, 0xa6, 0xce, 0x7b, 0xb9, 0xc1, 0xeb, 0xfd, 0x63, 0x78, +0x63, 0x9c, 0x8b, 0x40, 0x20, 0x52, 0xc5, 0x75, 0x97, 0x1a, 0x76, 0x1f, +0x5a, 0xf2, 0xca, 0x99, 0x88, 0xbe, 0x76, 0xb7, 0x8e, 0xbc, 0x43, 0xce, +0xf9, 0x4d, 0xa8, 0x09, 0x81, 0x88, 0xba, 0x33, 0xab, 0x69, 0xf2, 0x3d, +0x0e, 0xce, 0x9d, 0x69, 0xbd, 0x41, 0xa8, 0xa9, 0x3f, 0x71, 0x18, 0xd0, +0x3b, 0x8c, 0xf5, 0xbc, 0xa9, 0xee, 0x43, 0x20, 0x2e, 0x87, 0x93, 0xaa, +0xdc, 0x69, 0xa8, 0x17, 0x71, 0x26, 0xa4, 0x81, 0x8b, 0x5d, 0xbf, 0xc7, +0xca, 0x42, 0x97, 0x3e, 0xd4, 0x54, 0xe9, 0xe6, 0x0f, 0x6a, 0x9e, 0xb0, +0xb2, 0xe0, 0xfa, 0x41, 0x53, 0xbb, 0x0b, 0xfa, 0xf0, 0x22, 0xce, 0x36, +0x70, 0xf3, 0x3f, 0x23, 0xe1, 0xa6, 0xf6, 0xbd, 0x87, 0x85, 0x79, 0x5e, +0x6d, 0xa3, 0x4d, 0xa8, 0x94, 0xb3, 0xc9, 0xc2, 0xa5, 0xa5, 0xdd, 0x84, +0x2c, 0xf2, 0x72, 0x2e, 0xe2, 0x62, 0x2b, 0x06, 0x12, 0xd7, 0x17, 0xc7, +0x1a, 0xe2, 0xd0, 0xb6, 0x17, 0xc1, 0xa6, 0x69, 0x4c, 0x76, 0xb7, 0xd9, +0x68, 0xc4, 0x63, 0x88, 0xee, 0x45, 0xd8, 0x50, 0x9a, 0x7f, 0x06, 0x8b, +0x7f, 0x0e, 0x4c, 0x92, 0x03, 0xef, 0xc0, 0x91, 0x73, 0x28, 0xf6, 0xec, +0x63, 0x57, 0x8d, 0x99, 0x62, 0x14, 0x18, 0x00, 0x59, 0xe8, 0xde, 0x1b, +0xf5, 0xa9, 0x99, 0x05, 0x71, 0x76, 0xed, 0xc7, 0x1f, 0xa3, 0x87, 0x38, +0x4c, 0x98, 0x8d, 0xd8, 0x6c, 0x81, 0x9d, 0x2c, 0xe2, 0x50, 0xde, 0x83, +0xab, 0x39, 0xff, 0x08, 0x50, 0xc5, 0x02, 0x55, 0x53, 0x69, 0x2f, 0x61, +0x26, 0x62, 0xe5, 0x39, 0x37, 0x49, 0x84, 0x9d, 0xa0, 0x27, 0xa6, 0x0c, +0x0b, 0x13, 0xbb, 0xd6, 0x42, 0x5e, 0x04, 0x42, 0xfd, 0x9a, 0x94, 0xdd, +0x13, 0x28, 0x0d, 0x07, 0x26, 0x88, 0xb7, 0x17, 0x39, 0x0d, 0x62, 0xb3, +0xdb, 0x24, 0x89, 0x87, 0x13, 0xea, 0xdb, 0xcd, 0x2d, 0x71, 0xa8, 0x8f, +0x0d, 0x12, 0xb4, 0x3d, 0x41, 0x62, 0x2d, 0x50, 0x72, 0x00, 0xef, 0x89, +0x48, 0x30, 0x51, 0x9e, 0x84, 0x9a, 0xae, 0xbe, 0x03, 0x23, 0x0a, 0x33, +0x1e, 0x43, 0x3d, 0x22, 0xc1, 0xad, 0x74, 0xd0, 0xc5, 0x02, 0x15, 0xcb, +0x8b, 0x78, 0x71, 0x4a, 0x9b, 0x1d, 0xed, 0x36, 0xd3, 0x1e, 0x6f, 0x2e, +0x2c, 0x98, 0xe8, 0xa8, 0x68, 0xa2, 0xf8, 0xf3, 0xc7, 0x8b, 0x00, 0x48, +0x1c, 0x6a, 0x7a, 0x71, 0xbe, 0x82, 0x50, 0xd3, 0x8e, 0x90, 0x93, 0xfb, +0x7b, 0x09, 0x90, 0xda, 0xe4, 0x7f, 0xff, 0x8e, 0x77, 0x50, 0xff, 0x1c, +0x70, 0xe4, 0x22, 0xa0, 0xc7, 0x85, 0x29, 0x46, 0xa8, 0xe9, 0x59, 0x4b, +0x71, 0x26, 0x0a, 0x54, 0xce, 0x2d, 0x61, 0x57, 0x5d, 0x3c, 0x3c, 0x68, +0x9e, 0xcb, 0x65, 0x7f, 0xe2, 0x41, 0x48, 0xaf, 0x27, 0x47, 0x57, 0x58, +0x68, 0x93, 0x29, 0x91, 0x40, 0x4c, 0x3c, 0x5a, 0x68, 0x7e, 0x07, 0x75, +0x35, 0x59, 0x87, 0x40, 0x40, 0x07, 0xa4, 0x38, 0x9f, 0x42, 0x78, 0x15, +0x98, 0x1c, 0xcf, 0xee, 0xbe, 0x26, 0xc4, 0x04, 0x23, 0x79, 0xd3, 0x8e, +0x44, 0x35, 0xf4, 0xc8, 0x95, 0x64, 0x9d, 0x78, 0x0f, 0xbf, 0x7f, 0xff, +0xde, 0x6a, 0x27, 0xce, 0x24, 0x81, 0x66, 0x88, 0x5c, 0xfa, 0x8a, 0x07, +0x01, 0xdd, 0x70, 0x2a, 0xd4, 0x24, 0xde, 0x83, 0x88, 0xc3, 0x5a, 0x88, +0x89, 0xf0, 0x12, 0x8c, 0x32, 0x0f, 0xf0, 0x20, 0x60, 0x88, 0xc9, 0x21, +0xbb, 0x1e, 0xad, 0xbb, 0x77, 0x3b, 0xcf, 0x40, 0x84, 0x57, 0x9a, 0xd2, +0xee, 0x01, 0x3a, 0x98, 0x07, 0x93, 0x36, 0xee, 0x74, 0xe7, 0x0f, 0x30, +0x32, 0xfe, 0xa1, 0xdb, 0x09, 0x22, 0x76, 0xd7, 0x89, 0xb2, 0x65, 0xb2, +0xdb, 0x32, 0x82, 0x30, 0xb9, 0xbf, 0xb5, 0xfb, 0x00, 0xbd, 0xcc, 0x85, +0xfb, 0x41, 0x43, 0x18, 0x00, 0x82, 0x09, 0x04, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x71, +0xf3, 0x06, 0x00, 0x00, 0xf0, 0x97, 0xaf, 0x5f, 0xbf, 0xfe, 0xe7, 0xcf, +0x2f, 0x77, 0x9e, 0x04, 0x00, 0x00, 0x58, 0x16, 0x6f, 0x00, 0x00, 0x00, +0xef, 0xcc, 0x7f, 0xec, 0x0d, 0xef, 0x01, 0x00, 0x00, 0x94, 0x9b, 0x0f, +0x2b, 0xbd, 0x7d, 0xfb, 0xf6, 0xed, 0x7f, 0x8e, 0xfc, 0x03, 0x00, 0xc0, +0xf0, 0x88, 0xa7, 0xb0, 0x78, 0x51, 0x10, 0xcf, 0xe1, 0xcd, 0x0b, 0x05, +0x00, 0x00, 0x8c, 0xe6, 0x29, 0xfc, 0xb1, 0x49, 0x44, 0xe1, 0xcb, 0x97, +0x2f, 0xff, 0xb5, 0xc2, 0x60, 0x6c, 0xe2, 0x31, 0x01, 0x00, 0x8c, 0x23, +0x08, 0xb3, 0x78, 0x06, 0x1b, 0x82, 0xf0, 0x6e, 0x84, 0x97, 0x00, 0x00, +0xc6, 0xf6, 0x10, 0x9e, 0x19, 0xd5, 0x4b, 0x00, 0x00, 0x9d, 0x71, 0x57, +0x51, 0x38, 0x28, 0x08, 0x78, 0x0f, 0x00, 0x00, 0xbd, 0x7a, 0x0c, 0x5a, +0x7d, 0x14, 0xc1, 0xf0, 0x1e, 0x00, 0x00, 0x3a, 0x61, 0x3a, 0x11, 0x42, +0xc2, 0x7b, 0x00, 0x00, 0x40, 0x1c, 0x0e, 0xd9, 0xcc, 0x23, 0x05, 0x00, +0x40, 0x1c, 0x3e, 0x98, 0xcf, 0x5b, 0x00, 0x00, 0x40, 0xe3, 0xcc, 0x11, +0xbd, 0x06, 0xce, 0x3d, 0x00, 0x00, 0xf4, 0x40, 0xc4, 0x64, 0x34, 0xde, +0x03, 0x00, 0x00, 0xe2, 0xf0, 0x32, 0x31, 0x8d, 0xf7, 0x00, 0x00, 0xd0, +0x30, 0x8b, 0x8b, 0x1f, 0x56, 0xa2, 0xe7, 0x12, 0x00, 0x40, 0xeb, 0xe2, +0xf0, 0xfd, 0xfb, 0xf7, 0x7f, 0x62, 0x0a, 0x83, 0x7c, 0xbd, 0x9f, 0x3f, +0x7f, 0xbe, 0x2d, 0xcb, 0xb2, 0x56, 0xbd, 0x24, 0xa5, 0xae, 0x77, 0x6f, +0x31, 0xca, 0x5e, 0x69, 0x1b, 0x0e, 0x00, 0x90, 0x80, 0x14, 0x09, 0xe9, +0xb7, 0x1f, 0x3f, 0x7e, 0x3c, 0x04, 0xe2, 0xf7, 0xef, 0xdf, 0x6f, 0xf2, +0xab, 0xff, 0x3e, 0x53, 0xd8, 0xab, 0x49, 0xfe, 0xdb, 0x7b, 0x19, 0x7a, +0x81, 0xd0, 0x74, 0x70, 0xc1, 0x9f, 0x1d, 0x87, 0xef, 0x00, 0x00, 0xa2, +0x33, 0xa5, 0x10, 0x87, 0x50, 0x28, 0x7e, 0xfd, 0xfa, 0xf5, 0x10, 0x89, +0x23, 0x5e, 0x8a, 0x24, 0xb6, 0x03, 0xe1, 0x98, 0xfd, 0xe7, 0x9d, 0x54, +0x14, 0xcc, 0xdf, 0x99, 0x78, 0x95, 0x00, 0x00, 0x95, 0x7b, 0x0e, 0x6e, +0x23, 0xdc, 0x24, 0x22, 0x21, 0x16, 0xf3, 0x6c, 0x05, 0xf9, 0x0d, 0x00, +0x80, 0x06, 0x3d, 0x87, 0x35, 0x91, 0x30, 0xe1, 0xa6, 0x58, 0x46, 0xee, +0x01, 0x00, 0xa0, 0x65, 0x71, 0x70, 0x26, 0xdc, 0x24, 0x22, 0x21, 0xbf, +0x3a, 0x9a, 0xfe, 0x01, 0x00, 0x20, 0x0e, 0xd6, 0x34, 0x71, 0xed, 0xae, +0x1f, 0xbc, 0xa3, 0xe9, 0x1f, 0x00, 0x40, 0x2f, 0xe2, 0xe0, 0x7c, 0xd5, +0x92, 0xe4, 0x22, 0x7c, 0xf9, 0x2b, 0xe2, 0x00, 0x00, 0x50, 0x10, 0x59, +0x4c, 0x93, 0x1c, 0x82, 0x73, 0x17, 0x93, 0xd6, 0xee, 0xdc, 0xa9, 0x6c, +0xf2, 0x0e, 0x00, 0x00, 0x11, 0xb8, 0x5f, 0xb9, 0xfd, 0xcd, 0x25, 0x0e, +0x35, 0x1d, 0x29, 0x7b, 0x45, 0x1c, 0x00, 0x00, 0xe2, 0x31, 0x47, 0xbe, +0xcb, 0x21, 0xba, 0x17, 0xb1, 0x37, 0xcc, 0xe4, 0x45, 0x0e, 0x71, 0x00, +0x00, 0xb8, 0x2a, 0x0c, 0xb5, 0x7a, 0x0d, 0x6e, 0xa5, 0xaa, 0xe9, 0x95, +0x88, 0xf9, 0xb3, 0x0e, 0xe4, 0x1c, 0x00, 0x00, 0x4e, 0xf2, 0xc8, 0x33, +0xb4, 0x22, 0x0c, 0xce, 0x84, 0x8d, 0xb6, 0x04, 0x82, 0x2e, 0xb0, 0x00, +0x00, 0x11, 0x84, 0xa1, 0xe6, 0x50, 0x92, 0xdb, 0x19, 0x42, 0x92, 0x9f, +0xc1, 0xb4, 0xce, 0x98, 0xf1, 0x1a, 0x00, 0x00, 0xce, 0x89, 0xc2, 0x1c, +0x36, 0xbd, 0x6b, 0xdc, 0x26, 0x04, 0x01, 0x00, 0xe0, 0x1c, 0x92, 0xa0, +0x5d, 0x5a, 0x16, 0x85, 0x17, 0x15, 0x4b, 0x33, 0xaf, 0x18, 0x00, 0xe0, +0xa0, 0x97, 0xd0, 0x5a, 0x5e, 0xc1, 0x3d, 0xb9, 0x1b, 0xc2, 0xd1, 0x36, +0x03, 0x00, 0xe0, 0xb0, 0x18, 0x4c, 0xce, 0xb4, 0xb0, 0x6e, 0x3d, 0x74, +0x24, 0x82, 0x60, 0xfb, 0x2d, 0x69, 0xcb, 0x6f, 0x47, 0x57, 0x56, 0x80, +0x53, 0x0b, 0xc3, 0x2b, 0xb3, 0x3d, 0xf1, 0x43, 0xbb, 0xbb, 0xb8, 0xb7, +0x73, 0x41, 0x62, 0xcf, 0x40, 0xc3, 0x45, 0x3d, 0x88, 0x81, 0xdb, 0xb8, +0xff, 0xc1, 0xf6, 0x5b, 0x12, 0xef, 0xe1, 0x99, 0x40, 0x78, 0x2f, 0x09, +0x00, 0x21, 0x48, 0xb9, 0x4b, 0xb4, 0x95, 0x20, 0x2b, 0x97, 0xad, 0xa8, +0x4d, 0x46, 0x50, 0xe0, 0x3c, 0x77, 0xbb, 0xf3, 0x0f, 0x84, 0xfc, 0x93, +0x75, 0x96, 0x54, 0x5e, 0x35, 0x39, 0xf8, 0x26, 0xc2, 0x20, 0xa6, 0x82, +0xa0, 0x6d, 0xbe, 0x11, 0x08, 0x80, 0x40, 0x10, 0x6a, 0x5f, 0x14, 0x82, +0xd2, 0xc2, 0x25, 0x10, 0x10, 0xbc, 0x91, 0xcf, 0x62, 0xf0, 0x78, 0xaf, +0xb2, 0x4b, 0x56, 0x93, 0x45, 0x51, 0x7e, 0x95, 0x85, 0xf0, 0x59, 0x22, +0x56, 0x9e, 0xb5, 0xfd, 0x77, 0xf2, 0x77, 0x7b, 0x11, 0x0c, 0xf9, 0x39, +0xe4, 0x39, 0x68, 0xa7, 0x56, 0x7b, 0xef, 0x83, 0xb6, 0xf8, 0x46, 0x20, +0x80, 0x05, 0xa4, 0x83, 0x9a, 0xf4, 0x17, 0xde, 0xc8, 0x9a, 0x27, 0xd2, +0xd3, 0x3b, 0xfc, 0x10, 0xd2, 0xb3, 0x22, 0xa0, 0xd7, 0x66, 0x8a, 0xa9, +0x28, 0x1c, 0x7d, 0xd7, 0x2a, 0x12, 0x76, 0x21, 0xd5, 0xce, 0xa6, 0x67, +0xbe, 0x9e, 0xab, 0xa8, 0xf1, 0x9e, 0xde, 0xf3, 0xa0, 0x37, 0xc7, 0xa9, +0x58, 0xaa, 0x57, 0xf1, 0x4c, 0x20, 0xfc, 0xcf, 0xcd, 0x86, 0x04, 0xfa, +0xf3, 0x12, 0x7a, 0xa8, 0x32, 0x71, 0x17, 0x0f, 0x39, 0x05, 0x07, 0x9c, +0x5a, 0x09, 0x61, 0x7d, 0xf0, 0x06, 0x54, 0x04, 0x74, 0xe1, 0xb6, 0x26, +0x0b, 0x7a, 0xec, 0x05, 0xdc, 0x2e, 0xac, 0xa1, 0x58, 0x1c, 0x69, 0x62, +0xe7, 0x0a, 0xe7, 0x1b, 0xec, 0xe7, 0x0f, 0x2f, 0x02, 0xd2, 0xd6, 0xde, +0xaf, 0x04, 0xc2, 0x71, 0x3b, 0x1c, 0x74, 0x24, 0x0a, 0x4b, 0xef, 0xb1, +0xe4, 0x98, 0xe2, 0x61, 0x84, 0xc3, 0x7a, 0x1e, 0x53, 0x46, 0x0f, 0xe4, +0xe6, 0x82, 0x7c, 0xc1, 0x2b, 0x41, 0xc8, 0xb9, 0x58, 0xdb, 0xb8, 0x7d, +0xf8, 0xfd, 0x6b, 0xf7, 0x2a, 0xac, 0x27, 0xb4, 0x76, 0x9d, 0xa8, 0x15, +0x90, 0x1d, 0x02, 0x31, 0xb1, 0xc4, 0x00, 0xa2, 0x80, 0xad, 0x86, 0xb2, +0x36, 0xc2, 0x59, 0xd6, 0x1b, 0x59, 0xb3, 0x45, 0xff, 0x4d, 0xf0, 0xef, +0xde, 0x7f, 0x7f, 0x8f, 0x18, 0x84, 0x8b, 0x72, 0xee, 0x1d, 0xfc, 0x9a, +0x37, 0x61, 0x4d, 0x3e, 0x7f, 0x8d, 0xe3, 0x6f, 0x4d, 0xdc, 0xec, 0xb3, +0xb3, 0x02, 0xb1, 0xe3, 0x2e, 0x6a, 0x0e, 0xcb, 0xc1, 0xcb, 0xc5, 0xf8, +0x66, 0x26, 0xbf, 0xee, 0xf8, 0x66, 0xbb, 0x08, 0x1c, 0xb5, 0x20, 0x76, +0xfe, 0xaa, 0x1c, 0xf4, 0x43, 0xe8, 0x08, 0x51, 0x68, 0xdf, 0x34, 0x79, +0xac, 0x42, 0xa1, 0x25, 0x97, 0x36, 0xf4, 0x51, 0x43, 0x58, 0x47, 0x13, +0xbd, 0x39, 0xc2, 0x5b, 0x2e, 0x51, 0x59, 0xab, 0x3e, 0x4f, 0x7d, 0x96, +0xd6, 0xc3, 0xd8, 0xd1, 0xda, 0x1b, 0x81, 0x18, 0x7c, 0xd1, 0x9f, 0xcc, +0x42, 0xfd, 0x5e, 0x07, 0xae, 0x0b, 0xf1, 0xb3, 0xce, 0x8e, 0x29, 0x26, +0xa3, 0xdd, 0xb9, 0xda, 0xcf, 0xc1, 0xa2, 0x3a, 0x8e, 0xe7, 0x52, 0x63, +0x25, 0x91, 0xad, 0xfa, 0x69, 0x25, 0x17, 0xa1, 0xc9, 0xf7, 0x50, 0x28, +0x9e, 0xe5, 0x27, 0x10, 0x88, 0x71, 0x04, 0x60, 0x75, 0xb7, 0x6f, 0x17, +0x7e, 0x16, 0x24, 0x0c, 0x3b, 0xee, 0xf5, 0xb4, 0x2a, 0xba, 0xd6, 0x5b, +0xd3, 0xaa, 0xaf, 0x1d, 0xff, 0x9e, 0x76, 0x1b, 0x9d, 0x88, 0xc0, 0xfb, +0xa1, 0x1f, 0x16, 0x7f, 0x0c, 0xc3, 0x62, 0x89, 0x8b, 0xa3, 0xd4, 0xb5, +0x5a, 0xee, 0x6b, 0xa1, 0x1f, 0xc2, 0x2e, 0x18, 0x86, 0x65, 0x34, 0xc2, +0x4c, 0x95, 0x88, 0xc1, 0xe4, 0x3a, 0xea, 0x16, 0x89, 0x61, 0x58, 0x37, +0x5e, 0xc4, 0xc4, 0x12, 0x5d, 0x40, 0x08, 0x7a, 0x6d, 0x0e, 0x86, 0x61, +0x58, 0x5f, 0x67, 0x67, 0x1c, 0x87, 0xe6, 0xd2, 0x86, 0x89, 0x10, 0x02, +0x0c, 0xc3, 0x1a, 0x17, 0x09, 0xf2, 0x11, 0x17, 0x92, 0xc6, 0x53, 0x98, +0x33, 0x60, 0x60, 0x61, 0x18, 0xd6, 0x8b, 0x71, 0x47, 0xc4, 0xc9, 0x04, +0x32, 0x9e, 0x01, 0x86, 0x61, 0x83, 0x18, 0xa5, 0xaf, 0xaf, 0x42, 0x45, +0x0c, 0x92, 0xb8, 0xf5, 0xe5, 0x08, 0x2c, 0x86, 0x35, 0x65, 0x37, 0x04, +0xc1, 0xf7, 0xfb, 0x41, 0x10, 0xd2, 0x8a, 0x43, 0xad, 0x3d, 0x6d, 0x30, +0x0c, 0xe3, 0x9e, 0x88, 0x4f, 0x5e, 0x02, 0x82, 0x90, 0xb7, 0x5f, 0x0c, +0xe2, 0x80, 0x61, 0xe4, 0x21, 0xaa, 0x4e, 0x2e, 0x93, 0x47, 0xc8, 0xef, +0x39, 0xec, 0x6c, 0x16, 0x86, 0x61, 0x18, 0x02, 0x81, 0x28, 0x8c, 0x64, +0xda, 0xb9, 0x93, 0x67, 0x81, 0x61, 0x24, 0xa9, 0xab, 0x09, 0x21, 0x21, +0x0a, 0xe5, 0x4d, 0xdb, 0x27, 0xef, 0xe8, 0x24, 0x89, 0x61, 0x18, 0xad, +0x37, 0x10, 0x86, 0xd1, 0x42, 0x4b, 0x3b, 0x2e, 0x2a, 0xc1, 0x30, 0x8c, +0xf0, 0x52, 0x7a, 0x61, 0xe0, 0xc5, 0xd6, 0x63, 0x7a, 0x59, 0x09, 0xde, +0x03, 0x86, 0x71, 0x92, 0xba, 0x24, 0x5c, 0x47, 0x59, 0x61, 0xd5, 0x12, +0xde, 0x03, 0x86, 0xb5, 0x67, 0x3d, 0xb5, 0xfd, 0xbe, 0xe1, 0x35, 0x6c, +0xbf, 0x64, 0xbd, 0xb1, 0x6d, 0xe5, 0xda, 0xcf, 0x29, 0x85, 0x69, 0x43, +0x42, 0xf9, 0xbe, 0x9a, 0x98, 0x6e, 0xf1, 0xd2, 0x15, 0x0c, 0x1b, 0x5c, +0x1c, 0xba, 0x68, 0xd4, 0x77, 0x1f, 0xe1, 0x0c, 0x83, 0xbd, 0x0a, 0x74, +0xe7, 0xa2, 0x6f, 0x2f, 0x94, 0x2f, 0xf2, 0x5e, 0x34, 0x31, 0x8d, 0x38, +0x60, 0x58, 0x73, 0xe2, 0xd0, 0x45, 0x52, 0xfa, 0xde, 0x43, 0x48, 0x49, +0x7e, 0x86, 0x60, 0xa1, 0x9f, 0x2a, 0x5a, 0xe8, 0x4f, 0x87, 0xfb, 0xc4, +0x73, 0x20, 0xb4, 0x84, 0x61, 0xcd, 0xd9, 0xd4, 0x45, 0x58, 0xa9, 0x15, +0x71, 0xd8, 0xd8, 0xed, 0x4f, 0x8d, 0x2e, 0xfc, 0xbb, 0x84, 0x5b, 0x73, +0x0f, 0x78, 0x0f, 0x18, 0x46, 0x39, 0x6b, 0x09, 0xe6, 0x9a, 0x33, 0xff, +0x81, 0x18, 0x0c, 0x75, 0xe9, 0x86, 0xfc, 0xec, 0x78, 0x0f, 0x18, 0x86, +0x38, 0x14, 0xa3, 0x96, 0xbc, 0x83, 0x7a, 0x07, 0xa3, 0x8a, 0xc1, 0x1a, +0x7a, 0xee, 0x81, 0xb2, 0x56, 0x0c, 0x3b, 0x54, 0x4e, 0x3a, 0x07, 0xa6, +0x11, 0x86, 0x0f, 0xf7, 0xcd, 0xc4, 0x8e, 0x9c, 0xf8, 0xef, 0x3d, 0xf5, +0xb4, 0x06, 0xdd, 0x2a, 0x0a, 0x15, 0x71, 0xdb, 0x52, 0x10, 0x5e, 0xd2, +0x73, 0x0f, 0x84, 0x97, 0x30, 0x6c, 0xf7, 0x41, 0xb4, 0xdb, 0xc1, 0xf5, +0x6f, 0xf2, 0x6b, 0xd0, 0xa2, 0xe2, 0xb1, 0xf7, 0x60, 0x70, 0xb0, 0xa9, +0x9d, 0x7a, 0x5c, 0x84, 0x92, 0x0b, 0x84, 0x79, 0x80, 0xd6, 0x33, 0x40, +0x0c, 0x76, 0x84, 0x97, 0x38, 0xf7, 0x80, 0x61, 0x45, 0xab, 0x85, 0xac, +0xe7, 0x11, 0xda, 0x34, 0xc4, 0x3a, 0x16, 0xfb, 0xdc, 0x83, 0xa9, 0x24, +0x22, 0x4c, 0x14, 0x21, 0xbc, 0x44, 0xc7, 0x56, 0x0c, 0x1b, 0x2b, 0xac, +0x53, 0x5d, 0x28, 0xe3, 0x6c, 0x2c, 0x6e, 0x25, 0x54, 0xc4, 0x8b, 0x8a, +0xf4, 0x4e, 0xb4, 0x7a, 0x89, 0xfc, 0x03, 0x86, 0x3d, 0x15, 0x07, 0x36, +0xa1, 0x39, 0x16, 0xa4, 0xb5, 0xc4, 0x8d, 0x3d, 0x48, 0x66, 0x84, 0x60, +0x26, 0x54, 0x94, 0x9c, 0x45, 0x4f, 0x4e, 0xd3, 0xf2, 0x04, 0xc3, 0xfa, +0x6f, 0x7c, 0xd7, 0x9c, 0x60, 0xb8, 0x7e, 0xcf, 0x16, 0x54, 0x9f, 0x17, +0xa2, 0x6b, 0x2b, 0x86, 0x21, 0x0e, 0x00, 0x6b, 0xcc, 0x74, 0x6d, 0xc5, +0xb0, 0x68, 0x95, 0x4a, 0x00, 0xfd, 0x85, 0x97, 0x28, 0x6f, 0xc5, 0x62, +0x5b, 0x07, 0xe3, 0x69, 0x61, 0x79, 0x80, 0xa1, 0x91, 0x5c, 0x8f, 0x88, +0x03, 0x57, 0x8a, 0x62, 0xb1, 0xc5, 0xa1, 0x71, 0x81, 0x98, 0x59, 0x1d, +0x60, 0xf8, 0xfc, 0x83, 0x56, 0x2f, 0xf5, 0x5c, 0xde, 0x2a, 0x0b, 0x15, +0xc9, 0x77, 0xbc, 0x07, 0xc4, 0x01, 0xe0, 0x18, 0x53, 0xef, 0xad, 0xbd, +0xe5, 0xe7, 0xe2, 0x6c, 0x47, 0xfe, 0x83, 0x64, 0x0d, 0x8f, 0x27, 0xc2, +0x4a, 0x00, 0x61, 0xfe, 0xa1, 0xd7, 0x1d, 0xb6, 0x88, 0x03, 0xb9, 0x95, +0xfc, 0xcf, 0xbc, 0xd1, 0x82, 0x07, 0xc4, 0x01, 0x40, 0xc3, 0x4b, 0xbd, +0xe7, 0x1f, 0xf0, 0x1e, 0xca, 0x78, 0x0f, 0x8d, 0x3e, 0x73, 0xc4, 0x01, +0xc0, 0x70, 0xef, 0xfd, 0xde, 0x69, 0xbc, 0x87, 0xfc, 0x26, 0x63, 0xa9, +0x41, 0xef, 0x01, 0x71, 0x00, 0x08, 0x05, 0x42, 0xf3, 0x0f, 0x3d, 0xee, +0xb2, 0x1b, 0x0e, 0x73, 0x34, 0xfd, 0xcc, 0x1b, 0x3c, 0x8d, 0x4f, 0x42, +0x1a, 0x60, 0x85, 0xa9, 0xd7, 0x03, 0x72, 0x0d, 0x87, 0x39, 0x9a, 0x0e, +0xe7, 0xb5, 0x36, 0x96, 0x38, 0x21, 0x0d, 0xb0, 0x81, 0xde, 0x1e, 0xd7, +0x63, 0x05, 0x93, 0x2c, 0x52, 0x84, 0x96, 0xf2, 0x9a, 0xf6, 0xf2, 0x6a, +0xe5, 0xf3, 0xfa, 0xc6, 0x7b, 0x9c, 0x90, 0x06, 0x58, 0x43, 0x77, 0x7c, +0xbd, 0x09, 0x84, 0x78, 0x0f, 0x84, 0x96, 0xf2, 0x87, 0x96, 0x5a, 0xf2, +0x1e, 0x7c, 0x08, 0x8c, 0xbe, 0x6f, 0x00, 0x5b, 0xf9, 0x07, 0x4d, 0x50, +0xf7, 0x56, 0xe2, 0x8a, 0xf7, 0x50, 0x26, 0xb4, 0xd4, 0x92, 0xf7, 0x40, +0x68, 0x09, 0x60, 0x67, 0xfe, 0xa1, 0x27, 0x81, 0x10, 0x71, 0x20, 0xf7, +0x90, 0x5f, 0x1c, 0x5a, 0xf2, 0x42, 0xfd, 0x58, 0x27, 0xb4, 0x04, 0xf0, +0x84, 0xf7, 0x03, 0x72, 0xbd, 0x94, 0xb8, 0xb6, 0x98, 0x24, 0xed, 0x45, +0x1c, 0x1a, 0x1b, 0x43, 0x94, 0xb4, 0x02, 0xbc, 0x12, 0x08, 0x9d, 0xdc, +0x3d, 0x2c, 0xa8, 0xb2, 0x2b, 0x6c, 0x2d, 0x49, 0xda, 0xba, 0xa7, 0xa6, +0xe3, 0xa7, 0xc1, 0xc4, 0x34, 0x00, 0x3c, 0xa3, 0xb7, 0x04, 0xb5, 0x86, +0xcb, 0xc8, 0x3d, 0xe4, 0x4b, 0x48, 0xab, 0x38, 0xb4, 0x12, 0x9e, 0x24, +0x31, 0x0d, 0xb0, 0x8f, 0x0f, 0x09, 0xea, 0xd6, 0x17, 0xd5, 0xde, 0x4f, +0x83, 0xd7, 0x28, 0xc4, 0x2a, 0x0e, 0x8d, 0x8d, 0x1d, 0x0e, 0xc4, 0x01, +0x1c, 0xc9, 0x3f, 0xb4, 0x7e, 0x07, 0x75, 0xaf, 0xa5, 0xba, 0x35, 0xee, +0xbe, 0x1b, 0x17, 0x07, 0xf2, 0x0e, 0x00, 0x3b, 0xb8, 0x35, 0x9c, 0x5c, +0xdc, 0x14, 0x07, 0x12, 0xd3, 0x78, 0x0e, 0x8e, 0x92, 0x56, 0x80, 0xcb, +0xcc, 0x36, 0x86, 0xdc, 0xea, 0xc2, 0x6a, 0x43, 0x64, 0x88, 0x43, 0x9e, +0x02, 0x80, 0x16, 0xc5, 0x81, 0xbc, 0x03, 0xc0, 0x81, 0xdc, 0x83, 0xdd, +0x75, 0xb7, 0x78, 0xfe, 0x41, 0x7b, 0x2c, 0x21, 0x0e, 0x65, 0x0e, 0xc2, +0xb5, 0x34, 0x5e, 0x7c, 0xc5, 0x12, 0xe2, 0x00, 0xb0, 0x37, 0xf7, 0x10, +0x86, 0x0a, 0x5a, 0x5b, 0xa8, 0x74, 0x27, 0xdb, 0xfb, 0x15, 0xa9, 0x35, +0x0a, 0x44, 0x4b, 0xcf, 0x1b, 0x71, 0x00, 0x38, 0xc6, 0x14, 0xd6, 0xae, +0xb7, 0x14, 0x2a, 0xb0, 0x9f, 0x1d, 0x71, 0x40, 0x20, 0x76, 0xe4, 0x1c, +0x38, 0x29, 0x0d, 0xb0, 0x93, 0x9b, 0xed, 0xdc, 0xda, 0x9a, 0x38, 0xd8, +0x90, 0x12, 0xe5, 0xac, 0xe5, 0x3a, 0xb5, 0xb6, 0x20, 0x10, 0x74, 0x68, +0x05, 0x38, 0x88, 0x88, 0x83, 0x0d, 0x2d, 0xb5, 0xec, 0x39, 0x20, 0x0e, +0xe5, 0xaa, 0x98, 0x1a, 0x10, 0x08, 0x4a, 0x59, 0x01, 0x0e, 0x32, 0xeb, +0x22, 0x8b, 0xe7, 0x80, 0x5d, 0x79, 0x17, 0xb5, 0x0a, 0x84, 0x4f, 0x9c, +0x73, 0x08, 0x0e, 0xe0, 0x20, 0xef, 0x55, 0x4b, 0x2d, 0x2d, 0xae, 0x61, +0xa5, 0x12, 0x39, 0x07, 0xba, 0xe4, 0xee, 0xc8, 0x39, 0x00, 0xc0, 0x91, +0xbc, 0x83, 0xc4, 0x63, 0xc5, 0x6b, 0x68, 0x49, 0x1c, 0xc2, 0x4a, 0x25, +0x2d, 0x65, 0xd5, 0x05, 0xaa, 0xb5, 0xd3, 0xd2, 0xf2, 0x79, 0xd5, 0xec, +0xcf, 0x21, 0xef, 0x44, 0x4c, 0x1b, 0x0c, 0x5a, 0xd3, 0x3f, 0xd3, 0x5d, +0xfb, 0x33, 0xd3, 0xaf, 0x19, 0x9a, 0xfd, 0xbe, 0xd6, 0xce, 0x96, 0xa9, +0xca, 0xd7, 0xac, 0x75, 0x1c, 0x21, 0x10, 0x00, 0xc7, 0x59, 0x74, 0xa1, +0x69, 0x65, 0x21, 0x5d, 0x0b, 0x29, 0xe9, 0x82, 0xba, 0xf6, 0xfb, 0xba, +0xe8, 0xd5, 0xb2, 0xf0, 0xeb, 0x22, 0x6a, 0x17, 0x7b, 0x0d, 0xed, 0xbd, +0x12, 0x00, 0xf9, 0xb7, 0xb2, 0xd0, 0x5d, 0xb1, 0xf0, 0x6b, 0xc8, 0x06, +0x41, 0x7f, 0x2f, 0x14, 0x8f, 0xb3, 0xef, 0xa7, 0xd2, 0xf1, 0x43, 0x78, +0x09, 0xe0, 0x68, 0x68, 0xa9, 0x05, 0x71, 0xd0, 0xeb, 0x41, 0xd7, 0xbc, +0x06, 0x1b, 0xff, 0xb6, 0x49, 0xf6, 0xd0, 0xb4, 0xc2, 0x26, 0xc5, 0x4d, +0x72, 0x2a, 0x00, 0xcf, 0x76, 0xfd, 0xfa, 0xfb, 0xd6, 0xc2, 0x45, 0xdf, +0xfd, 0x9b, 0x40, 0x9d, 0x8d, 0x95, 0xaa, 0xd1, 0xbf, 0x7b, 0x9b, 0xf4, +0xb3, 0xac, 0x89, 0x8d, 0x88, 0x8b, 0x9a, 0xbc, 0xa3, 0xca, 0xaf, 0x71, +0xe5, 0xbc, 0x03, 0xc0, 0x5e, 0x74, 0xe7, 0xd8, 0x62, 0x38, 0x49, 0xfe, +0x7f, 0xeb, 0xb3, 0xeb, 0x22, 0xa5, 0x8b, 0xb6, 0x5d, 0xac, 0x9f, 0x09, +0xc6, 0x96, 0x85, 0x61, 0x19, 0x2b, 0x02, 0xa1, 0x10, 0xd8, 0x45, 0x5f, +0xfe, 0xad, 0x5d, 0x4c, 0xfd, 0x42, 0x3b, 0x99, 0xc5, 0x57, 0xac, 0xb7, +0x52, 0xcb, 0xa9, 0xe2, 0xf0, 0xde, 0xc4, 0xac, 0x07, 0xd8, 0x19, 0x5a, +0xaa, 0x3d, 0x4e, 0xaf, 0xde, 0x4d, 0xe8, 0x09, 0xc8, 0x02, 0x7c, 0x36, +0x46, 0x2e, 0xff, 0x6e, 0x4d, 0x38, 0xc2, 0x50, 0xcf, 0x9a, 0xf7, 0x11, +0x86, 0x7c, 0x8c, 0x27, 0xb2, 0x98, 0x9d, 0xff, 0xd4, 0xe9, 0xc2, 0xbf, +0x97, 0xdb, 0x95, 0x1c, 0x06, 0x1e, 0x04, 0x40, 0x05, 0xe2, 0x50, 0x73, +0xaf, 0x9c, 0x35, 0x61, 0x50, 0x8f, 0x21, 0xe5, 0xe7, 0x96, 0xaf, 0xad, +0xbb, 0x7d, 0xf5, 0x1e, 0xfc, 0x81, 0xaa, 0x65, 0x65, 0xf7, 0x7f, 0x73, +0x1c, 0xb4, 0x6a, 0x66, 0xf3, 0x41, 0x33, 0x3e, 0x80, 0x7d, 0xcc, 0x25, +0x93, 0xb6, 0xee, 0x60, 0x8e, 0xe1, 0x59, 0x28, 0x29, 0xb6, 0x71, 0xba, +0x36, 0x9e, 0x40, 0xb8, 0x3a, 0xcf, 0x40, 0x20, 0x10, 0x00, 0xaf, 0x76, +0x76, 0x35, 0x88, 0x83, 0x4d, 0xea, 0xae, 0x85, 0x74, 0xb4, 0x02, 0x29, +0x97, 0xa7, 0x43, 0x5f, 0x9e, 0xb8, 0x9b, 0x10, 0x04, 0x02, 0xa0, 0x31, +0x64, 0x87, 0x5c, 0x52, 0x1c, 0xb4, 0x04, 0x72, 0xab, 0xd2, 0xc8, 0x96, +0xa5, 0xba, 0xfc, 0xf5, 0xf1, 0x88, 0x43, 0xff, 0x02, 0xc1, 0x3b, 0x06, +0xd8, 0xa2, 0x44, 0xde, 0xa1, 0x56, 0x51, 0x70, 0xf4, 0xe5, 0x49, 0xc9, +0x84, 0x40, 0x00, 0xb4, 0xc5, 0x2d, 0x97, 0x40, 0xa8, 0x28, 0x3c, 0x0b, +0x1d, 0xe5, 0x0c, 0x1f, 0x21, 0x0e, 0xfd, 0x8e, 0x35, 0x77, 0x2c, 0xbf, +0x04, 0x00, 0x1b, 0xdc, 0x53, 0x4e, 0xc0, 0x57, 0xf9, 0x84, 0x0a, 0xdb, +0x5f, 0x20, 0x0e, 0x03, 0x09, 0x04, 0x6d, 0x36, 0x00, 0x0a, 0xb9, 0xfd, +0xb2, 0x18, 0x3c, 0x3b, 0xb5, 0x5c, 0xe1, 0x42, 0x41, 0xb2, 0x32, 0x31, +0x7e, 0xc7, 0x4e, 0x8b, 0x6f, 0x80, 0x46, 0x48, 0x96, 0x38, 0xb4, 0x77, +0x31, 0x14, 0xce, 0x27, 0xbc, 0x0a, 0x31, 0x4c, 0x0c, 0x83, 0x3c, 0x78, +0x21, 0xa6, 0x0f, 0x13, 0xc0, 0xc8, 0x13, 0x56, 0xbc, 0x07, 0x0d, 0x2b, +0xd5, 0xe6, 0x2d, 0x04, 0x87, 0xdc, 0x20, 0x2f, 0xb5, 0x9d, 0x85, 0xc0, +0x6b, 0x04, 0xc8, 0xed, 0xf2, 0x6b, 0x75, 0x52, 0x69, 0x71, 0xd0, 0x46, +0x71, 0x46, 0x14, 0xf0, 0x16, 0x10, 0x08, 0xfa, 0x30, 0x01, 0x94, 0x12, +0x08, 0x15, 0x87, 0x1c, 0xed, 0x9d, 0xad, 0x00, 0x88, 0x99, 0xe6, 0x77, +0xda, 0x02, 0x83, 0x12, 0xc6, 0xba, 0xa8, 0xed, 0x2c, 0x04, 0x02, 0x01, +0xb0, 0xc1, 0x14, 0x7b, 0xc2, 0xe9, 0xdd, 0x0b, 0x57, 0x5a, 0x85, 0x07, +0x8b, 0x7d, 0xd8, 0xe6, 0xda, 0x2e, 0xfe, 0x84, 0x07, 0x18, 0x73, 0x08, +0x04, 0x40, 0x02, 0x6e, 0xb1, 0x77, 0x73, 0x7a, 0x3d, 0xa9, 0xe4, 0x1e, +0xae, 0x74, 0x55, 0xe5, 0xd5, 0x20, 0x10, 0x08, 0x04, 0x40, 0x79, 0x81, +0x88, 0x1a, 0x0f, 0x8e, 0x91, 0x94, 0xe6, 0x64, 0x2b, 0x21, 0x26, 0x04, +0x02, 0xa0, 0x3c, 0xf7, 0x98, 0x15, 0x4c, 0xb6, 0x65, 0x46, 0x84, 0xc3, +0x50, 0x4c, 0x5a, 0x3c, 0x08, 0xca, 0x5c, 0x01, 0x4a, 0x4e, 0xd4, 0x58, +0x09, 0x6a, 0x0d, 0x2d, 0x45, 0xac, 0x5a, 0x42, 0x20, 0x10, 0x08, 0x0e, +0xca, 0x01, 0xb4, 0x3e, 0x51, 0xed, 0x79, 0x87, 0x18, 0x77, 0x58, 0x13, +0x62, 0xea, 0xdf, 0x73, 0x45, 0x20, 0x00, 0x06, 0x11, 0x88, 0xc8, 0xa1, +0x25, 0x04, 0x82, 0x71, 0x47, 0x2f, 0x26, 0x80, 0x1e, 0x26, 0xaa, 0x6d, +0xa5, 0x11, 0xeb, 0xcc, 0x03, 0xdd, 0x35, 0x19, 0x77, 0x7b, 0x16, 0xf5, +0x58, 0x4d, 0xff, 0xa8, 0x9a, 0x03, 0x48, 0x30, 0x51, 0x6d, 0xde, 0x21, +0x46, 0x68, 0x89, 0x1d, 0x1d, 0xe3, 0xce, 0x1d, 0xcb, 0x51, 0x45, 0xa9, +0x86, 0xc2, 0x63, 0x05, 0x88, 0x3c, 0x51, 0x6d, 0xde, 0x41, 0x7e, 0x75, +0x54, 0x95, 0xc0, 0x7e, 0x2e, 0xe5, 0x20, 0xcc, 0x82, 0x7e, 0x8b, 0xd8, +0x05, 0x80, 0x03, 0x97, 0x00, 0xb1, 0x04, 0x22, 0x45, 0x68, 0x89, 0xc9, +0x3a, 0x0c, 0x97, 0xee, 0x84, 0x08, 0x42, 0x90, 0xb1, 0xce, 0x54, 0xb0, +0x29, 0x01, 0x08, 0x38, 0x3d, 0xb9, 0xac, 0xf7, 0x20, 0x13, 0x36, 0xf2, +0x25, 0x30, 0x08, 0x44, 0xe3, 0x02, 0xe0, 0xdf, 0xa1, 0x86, 0x81, 0x42, +0xbb, 0x5f, 0xd9, 0xf9, 0x87, 0x21, 0xc8, 0x18, 0x63, 0x8f, 0xb0, 0x26, +0xc0, 0x67, 0x4e, 0x9d, 0xa2, 0x5e, 0xf1, 0x1e, 0xa6, 0xc8, 0x2d, 0xc3, +0x11, 0x88, 0xf6, 0x3c, 0xd1, 0x45, 0xc6, 0xc0, 0x9e, 0xcd, 0x42, 0x84, +0x05, 0x7d, 0x8e, 0xb5, 0xd1, 0x71, 0xe4, 0x21, 0x00, 0xe2, 0x09, 0x84, +0x4d, 0x4c, 0x8b, 0xf7, 0x60, 0x76, 0x5e, 0x31, 0x5b, 0x76, 0x20, 0x10, +0xf5, 0x7b, 0x08, 0x4b, 0xcc, 0x4a, 0xa2, 0xab, 0x0b, 0x79, 0xa4, 0xcf, +0xc1, 0xb8, 0x03, 0x50, 0xce, 0xec, 0xfa, 0xb5, 0x53, 0xab, 0x39, 0x31, +0x7d, 0x37, 0xbb, 0x48, 0x2a, 0x4a, 0xfa, 0x17, 0x86, 0xb9, 0xe4, 0x95, +0xa1, 0x4f, 0x4a, 0xa0, 0x63, 0xe4, 0x22, 0x38, 0x30, 0x07, 0xa0, 0x1c, +0x9d, 0xe8, 0x61, 0x59, 0x6b, 0x10, 0xb7, 0x8d, 0x22, 0x10, 0xc4, 0x82, +0xab, 0x65, 0xce, 0xed, 0x2d, 0x1c, 0x5c, 0xc4, 0x6f, 0x57, 0x3f, 0x9f, +0x9f, 0x0f, 0x6c, 0x4e, 0x00, 0xdc, 0x89, 0x12, 0x41, 0xf5, 0x1e, 0x34, +0x31, 0x1d, 0x7c, 0x3d, 0x04, 0xa2, 0xd3, 0x71, 0x52, 0xcb, 0x1d, 0xd2, +0x5e, 0x00, 0x9e, 0x85, 0x81, 0x62, 0x84, 0x39, 0x09, 0x33, 0x01, 0xf8, +0x9d, 0xd2, 0xa9, 0x96, 0x1a, 0xfe, 0x50, 0xdc, 0x94, 0x42, 0x20, 0x1c, +0xe5, 0x86, 0x35, 0x71, 0x2f, 0x19, 0x4e, 0x3a, 0xb3, 0x79, 0x88, 0xf0, +0x79, 0x09, 0x33, 0x01, 0x1c, 0x75, 0xc9, 0xed, 0xc1, 0x38, 0x9f, 0x7b, +0xb8, 0x25, 0x12, 0x08, 0x76, 0x70, 0x95, 0x50, 0x8b, 0xe7, 0x70, 0x70, +0xf3, 0x70, 0x69, 0x1c, 0x92, 0x03, 0x03, 0x38, 0x29, 0x10, 0x1b, 0xb9, +0x07, 0x04, 0x82, 0xf1, 0x51, 0x32, 0x39, 0x9d, 0xc2, 0x8b, 0xc0, 0x8b, +0x05, 0x16, 0x80, 0x33, 0x02, 0xa1, 0xe7, 0x1e, 0x52, 0x08, 0x04, 0x49, +0xc2, 0xba, 0xc2, 0x4b, 0x95, 0x79, 0x0f, 0x47, 0x42, 0x3f, 0x93, 0xa3, +0x59, 0x24, 0x40, 0x31, 0x81, 0xb8, 0x27, 0xf2, 0x20, 0x88, 0xff, 0xe2, +0x41, 0x44, 0xd9, 0x38, 0x44, 0x08, 0x8f, 0x4d, 0x0c, 0x01, 0x60, 0x01, +0x38, 0x27, 0x10, 0xd1, 0x77, 0x6d, 0x4c, 0xca, 0x2a, 0x89, 0x7a, 0x5f, +0x79, 0xe6, 0x71, 0x71, 0xf5, 0x5c, 0x04, 0x9b, 0x15, 0x40, 0x20, 0x4e, +0x0a, 0xc4, 0x2d, 0x91, 0x40, 0x90, 0x7f, 0xa8, 0x6c, 0x8c, 0x94, 0xaa, +0x62, 0x92, 0xf1, 0xe6, 0xbf, 0xf7, 0xe9, 0x4d, 0x43, 0x84, 0xcf, 0xce, +0x78, 0x84, 0x61, 0x39, 0x1c, 0x63, 0x96, 0x2a, 0xa6, 0x27, 0x39, 0x88, +0x4b, 0xbb, 0x4d, 0xe2, 0xbe, 0xf5, 0x8e, 0x93, 0xdc, 0xd5, 0x4c, 0x7e, +0x2c, 0xcc, 0xee, 0x7a, 0x3e, 0xea, 0xd2, 0xa6, 0x85, 0x33, 0x39, 0x30, +0x32, 0x87, 0x27, 0x8f, 0x88, 0x43, 0xaa, 0x33, 0x10, 0x4c, 0xc6, 0x26, +0x36, 0x14, 0xb2, 0x68, 0x3f, 0x7a, 0x30, 0x69, 0x1f, 0x26, 0x6d, 0xce, +0x17, 0xfe, 0x7a, 0xd4, 0x3b, 0xf5, 0xef, 0x7f, 0x76, 0x91, 0xc3, 0x8c, +0x57, 0xc4, 0x6d, 0xc7, 0xc1, 0x3c, 0x00, 0x3c, 0x08, 0x67, 0xba, 0xb8, +0xae, 0x09, 0x44, 0x8c, 0x30, 0x04, 0x02, 0xd1, 0x5f, 0x78, 0xca, 0x8f, +0xb1, 0x35, 0x9b, 0x8c, 0x18, 0xa4, 0x5e, 0x80, 0xa7, 0x8b, 0xc9, 0x76, +0x72, 0x11, 0x80, 0x40, 0x1c, 0x11, 0x09, 0xf7, 0xb7, 0x4e, 0x7c, 0x8a, +0x18, 0xa3, 0x9e, 0x78, 0x25, 0x90, 0x88, 0xd3, 0xe1, 0x4f, 0xbc, 0x08, +0x40, 0x20, 0x0e, 0x36, 0xec, 0xf3, 0xbb, 0xfd, 0xc9, 0xc5, 0x8d, 0x3d, +0x33, 0x09, 0x21, 0x99, 0x37, 0x73, 0x65, 0x23, 0xc3, 0xf9, 0x1c, 0x40, +0x20, 0x0e, 0x8a, 0x44, 0xcc, 0x1a, 0x79, 0xc2, 0x4b, 0x90, 0x81, 0x99, +0x31, 0x0a, 0x90, 0x41, 0x20, 0x24, 0xcc, 0x24, 0x22, 0xe1, 0xe2, 0x75, +0xe8, 0x04, 0x48, 0xce, 0xd5, 0x70, 0xa8, 0x17, 0x09, 0x3c, 0x09, 0x40, +0x20, 0xf6, 0x78, 0x11, 0x91, 0x44, 0x82, 0xbe, 0x37, 0x90, 0x8b, 0xcb, +0x07, 0xff, 0xfc, 0x86, 0x26, 0x46, 0x09, 0x2e, 0x40, 0xd5, 0x4c, 0x57, +0x27, 0x4b, 0x04, 0x91, 0xa0, 0x42, 0x04, 0x72, 0x12, 0xed, 0xe0, 0x9f, +0x29, 0xcd, 0x9d, 0x1c, 0xf9, 0x33, 0xc0, 0x83, 0xd8, 0x16, 0x09, 0x7f, +0x78, 0x8e, 0x98, 0x2e, 0x0c, 0x33, 0xee, 0x37, 0xc6, 0x33, 0x42, 0x01, +0xfd, 0xec, 0xa6, 0x62, 0x25, 0x9a, 0xe5, 0x6c, 0x84, 0x2f, 0x7f, 0xc5, +0x73, 0x80, 0xea, 0x49, 0x7c, 0x32, 0x9c, 0xb1, 0x0d, 0x7d, 0x10, 0xcb, +0xdd, 0xd6, 0xbb, 0xaa, 0x5f, 0x85, 0x9b, 0xbc, 0x20, 0x4d, 0x3c, 0x79, +0x28, 0xed, 0x45, 0x24, 0xee, 0x54, 0x8b, 0x48, 0xc0, 0xb8, 0x3b, 0xa9, +0xb5, 0xc9, 0x25, 0xe2, 0xe0, 0x4f, 0x59, 0x3f, 0xab, 0x25, 0xc7, 0x05, +0x87, 0x5a, 0x48, 0xdd, 0xa9, 0x96, 0xe2, 0x0b, 0x68, 0x9e, 0xc3, 0xb5, +0xe1, 0x22, 0x0e, 0x12, 0x4e, 0x5a, 0xcb, 0x3b, 0xc8, 0xef, 0x6d, 0xe4, +0x23, 0xd8, 0x51, 0x41, 0x6d, 0x24, 0xbd, 0xef, 0x82, 0xab, 0x4b, 0xa1, +0x07, 0xa6, 0xb3, 0x13, 0x60, 0x4d, 0x0c, 0xf4, 0xde, 0x6a, 0x0d, 0x35, +0x5d, 0x6d, 0xd7, 0x0c, 0x50, 0xdb, 0x06, 0xc9, 0x11, 0x6a, 0x82, 0x81, +0xb8, 0x54, 0xd1, 0x21, 0x21, 0xa5, 0x50, 0x24, 0xcc, 0xef, 0xe1, 0x62, +0x43, 0x0b, 0x24, 0x0b, 0x35, 0xe1, 0x45, 0x40, 0xf3, 0x5c, 0x49, 0x54, +0xaf, 0x25, 0xa7, 0x4d, 0x2e, 0x02, 0x81, 0x80, 0x26, 0x48, 0x5c, 0xd5, +0xc4, 0x3c, 0x80, 0x71, 0x77, 0x50, 0x6b, 0xa1, 0x26, 0x04, 0x02, 0x1a, +0x23, 0x65, 0x3e, 0x82, 0x30, 0x13, 0x34, 0xcd, 0xa5, 0x30, 0x93, 0xb9, +0x23, 0x22, 0x14, 0x08, 0x26, 0x06, 0xb4, 0x44, 0x92, 0x7c, 0x04, 0x07, +0x42, 0x61, 0x68, 0x17, 0x5b, 0x42, 0x4a, 0x92, 0x98, 0x0e, 0x45, 0xc3, +0x1f, 0x9c, 0x03, 0x18, 0x62, 0x1e, 0x38, 0xae, 0xd2, 0x85, 0x9e, 0x5d, +0xec, 0xb3, 0xb9, 0x08, 0x15, 0x08, 0xeb, 0xa2, 0x4b, 0xc8, 0x09, 0x81, +0x80, 0x16, 0xe7, 0x41, 0xec, 0x50, 0x13, 0x02, 0x01, 0xbd, 0x70, 0x3f, +0x23, 0x12, 0x6b, 0x07, 0xe4, 0x7c, 0x4e, 0x82, 0x10, 0x13, 0xb4, 0xc8, +0xe4, 0x48, 0x52, 0x03, 0x6c, 0xb2, 0x9c, 0xd9, 0x45, 0xe9, 0x25, 0x42, +0x5e, 0x64, 0x44, 0x1c, 0x28, 0xef, 0x83, 0x26, 0xbd, 0x08, 0x19, 0xbf, +0x12, 0x6e, 0xda, 0x32, 0x19, 0xe3, 0xa1, 0xe9, 0xd8, 0x97, 0x5f, 0x83, +0x79, 0x00, 0xd0, 0xe5, 0x24, 0x99, 0xc3, 0xc9, 0xa0, 0x83, 0xdf, 0x05, +0xb5, 0xde, 0x66, 0x32, 0x4c, 0x3c, 0x3a, 0x00, 0x80, 0xb1, 0xb9, 0x1b, +0xc3, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x90, 0x3b, 0x8f, 0x00, +0x00, 0x00, 0x42, 0xa6, 0x3f, 0x36, 0xf3, 0x18, 0x00, 0x00, 0xe0, 0x83, +0xe7, 0xf0, 0xe5, 0xcb, 0x97, 0xff, 0x7a, 0x91, 0x00, 0x00, 0x00, 0xf8, +0x17, 0x11, 0x07, 0x2f, 0x10, 0x00, 0x00, 0x00, 0xff, 0x7a, 0x0e, 0x5f, +0xbf, 0x7e, 0xfd, 0xcf, 0x9f, 0x5f, 0xdf, 0xbe, 0x7d, 0xfb, 0xf6, 0xbf, +0x3f, 0xbf, 0xde, 0x78, 0x24, 0x00, 0x00, 0x63, 0x23, 0x42, 0x30, 0x7b, +0x51, 0x78, 0xf3, 0xb6, 0xf0, 0x58, 0x00, 0x00, 0x10, 0x06, 0x2b, 0x0c, +0x6a, 0x24, 0xa8, 0x01, 0x00, 0x06, 0x64, 0x92, 0x1c, 0xc3, 0x86, 0x30, +0xa8, 0x51, 0xe2, 0x0a, 0x00, 0x30, 0x08, 0x8f, 0xfc, 0x82, 0x4f, 0x3e, +0xbf, 0x3d, 0x33, 0x12, 0xd4, 0x00, 0x00, 0x03, 0x78, 0x0a, 0x7f, 0x6c, +0xd9, 0x23, 0x0a, 0x8e, 0xf0, 0x12, 0x00, 0xc0, 0x18, 0xc2, 0x70, 0x42, +0x14, 0x1e, 0x46, 0xf5, 0x12, 0x00, 0x00, 0xc2, 0xb0, 0x6a, 0xbe, 0xcc, +0x15, 0x00, 0x00, 0x3a, 0x62, 0xb9, 0x22, 0x0c, 0x8e, 0xe4, 0x34, 0x00, +0x40, 0x57, 0x3c, 0xca, 0x54, 0xaf, 0x7a, 0x0d, 0x78, 0x0f, 0x00, 0x00, +0x7d, 0x71, 0x8f, 0x25, 0x0c, 0xc6, 0x26, 0x1e, 0x2b, 0x00, 0x40, 0xdb, +0xcc, 0xdf, 0xbf, 0x7f, 0xff, 0x47, 0x2c, 0x96, 0x38, 0xf8, 0xe4, 0x34, +0x00, 0x00, 0x34, 0xca, 0x4d, 0xc2, 0x40, 0x3f, 0x7e, 0xfc, 0xf8, 0x67, +0x59, 0x96, 0x98, 0x9e, 0x43, 0x8e, 0xd6, 0x1a, 0xe2, 0x9d, 0x50, 0x1d, +0x05, 0x00, 0x90, 0x80, 0x47, 0x48, 0xe9, 0xe7, 0xcf, 0x9f, 0x6f, 0x62, +0x31, 0xc5, 0x21, 0x83, 0xf7, 0x30, 0xf9, 0xfc, 0x06, 0x09, 0x70, 0x00, +0x80, 0x54, 0xe2, 0xf0, 0xeb, 0xd7, 0xaf, 0xa8, 0xe2, 0x20, 0x61, 0x2a, +0xef, 0x8d, 0x2c, 0x7e, 0x87, 0x7f, 0x77, 0x7f, 0x2f, 0x0b, 0x5a, 0x64, +0x61, 0xb7, 0xe6, 0xff, 0xde, 0xec, 0x6d, 0xda, 0xb0, 0xf7, 0xaf, 0x61, +0x5a, 0x87, 0x4f, 0xbc, 0x46, 0x00, 0x80, 0xc8, 0xe2, 0x20, 0x3b, 0x7c, +0x11, 0x86, 0x14, 0xe2, 0x20, 0xa2, 0xf3, 0xfb, 0xf7, 0xef, 0x87, 0x89, +0x00, 0xbc, 0xe8, 0xcf, 0x44, 0xe9, 0x2c, 0x00, 0x40, 0x6d, 0x9e, 0x83, +0x2c, 0xe0, 0x92, 0x7b, 0x88, 0xbd, 0x78, 0x8b, 0x20, 0xc8, 0xd7, 0xd5, +0xef, 0x21, 0xde, 0x44, 0x4c, 0x91, 0xa0, 0x74, 0x16, 0x00, 0x20, 0x01, +0x22, 0x0e, 0xb2, 0x60, 0xeb, 0xc2, 0x9d, 0x60, 0x67, 0xff, 0xc1, 0x44, +0x28, 0xe4, 0x7b, 0x89, 0xa7, 0x12, 0x51, 0x24, 0xe8, 0xeb, 0x04, 0x00, +0x10, 0x99, 0x45, 0x17, 0x6c, 0xb1, 0x98, 0x25, 0xad, 0x7b, 0x44, 0x22, +0x46, 0x22, 0xdc, 0xe7, 0x1e, 0xa8, 0x5c, 0x02, 0x00, 0x88, 0x29, 0x0e, +0x22, 0x08, 0x2a, 0x0e, 0x29, 0x42, 0x4b, 0x7b, 0x44, 0xe2, 0x8a, 0xd7, +0xe2, 0x3d, 0x10, 0x72, 0x0f, 0x00, 0x00, 0x11, 0x99, 0x34, 0x29, 0x9d, +0x2b, 0xb4, 0xb4, 0x66, 0x1a, 0xda, 0xba, 0xe0, 0xb9, 0x10, 0x5a, 0x02, +0x00, 0x88, 0x29, 0x0e, 0x12, 0x96, 0x29, 0x2d, 0x0e, 0x56, 0x24, 0x4e, +0x86, 0x9a, 0xb8, 0xcf, 0x1a, 0x00, 0x20, 0x22, 0x8f, 0x72, 0x56, 0x5b, +0x4d, 0x54, 0x52, 0x1c, 0xd4, 0xe4, 0xf3, 0x1c, 0x09, 0x71, 0x51, 0xb5, +0x04, 0x00, 0x10, 0x0f, 0x49, 0xe2, 0x2e, 0xf6, 0x4c, 0x42, 0xec, 0x52, +0x53, 0x17, 0xe7, 0x20, 0xdd, 0x5e, 0xcf, 0x81, 0xa4, 0x34, 0x00, 0x40, +0x0c, 0x64, 0xc7, 0x5d, 0x32, 0x21, 0xed, 0x76, 0x26, 0xad, 0x5f, 0xe5, +0x22, 0xf0, 0x1c, 0x00, 0x00, 0xe2, 0xb2, 0xe8, 0x21, 0x35, 0xd9, 0xa5, +0xe7, 0x2a, 0x65, 0x3d, 0xeb, 0x49, 0xb8, 0xed, 0x52, 0x56, 0x12, 0xd2, +0x00, 0x00, 0x91, 0x78, 0xf4, 0x28, 0x92, 0x30, 0x52, 0xcd, 0xa2, 0xe0, +0x56, 0x4a, 0x57, 0xd5, 0x4c, 0x5f, 0x26, 0x42, 0x4a, 0x00, 0x00, 0x17, +0x79, 0xe4, 0x1a, 0xfc, 0xc2, 0xfa, 0xd6, 0xa2, 0x99, 0x83, 0x6f, 0x9c, +0x6f, 0x00, 0x00, 0xb8, 0x80, 0x76, 0x34, 0x5d, 0x12, 0x36, 0xc1, 0xcb, +0xee, 0x41, 0x20, 0x0e, 0x00, 0x00, 0xe7, 0xbd, 0x84, 0x39, 0xc1, 0x55, +0xa0, 0x25, 0x84, 0x80, 0x64, 0x34, 0x00, 0x40, 0x04, 0x1e, 0x9e, 0x42, +0x0f, 0x5e, 0x82, 0x96, 0xdb, 0xba, 0xe7, 0x61, 0x26, 0x00, 0x00, 0x78, +0xe1, 0x2d, 0x2c, 0xad, 0x7b, 0x0b, 0xce, 0x24, 0x9f, 0x9d, 0xe9, 0xc3, +0xb4, 0x25, 0x76, 0x08, 0x04, 0x00, 0xc0, 0xb6, 0x28, 0x48, 0x0c, 0x7e, +0xee, 0xc1, 0x5b, 0x70, 0xbe, 0x9d, 0x86, 0xb4, 0xf6, 0xd0, 0x6a, 0xaa, +0x57, 0x3d, 0x98, 0xfc, 0xcf, 0x4d, 0xe5, 0x12, 0x00, 0x80, 0x86, 0x90, +0x7a, 0x49, 0x34, 0xbb, 0x95, 0x86, 0x7c, 0x56, 0x10, 0xb4, 0x0f, 0xd4, +0x0b, 0x81, 0x20, 0x51, 0x0d, 0x00, 0x84, 0x90, 0x7a, 0x08, 0x21, 0xb9, +0x27, 0x2d, 0xbd, 0xb7, 0x04, 0xe2, 0xc5, 0x89, 0x6e, 0x9a, 0xf1, 0x01, +0xc0, 0xb8, 0xe2, 0x20, 0xc2, 0x20, 0x8b, 0xa6, 0x2c, 0x94, 0xda, 0xd5, +0x54, 0x4d, 0xfe, 0x7f, 0x4f, 0xfb, 0x89, 0x5a, 0x4d, 0x7f, 0x06, 0x15, +0x03, 0xbd, 0xeb, 0x5a, 0xbc, 0x83, 0x3d, 0x2d, 0x3f, 0xa8, 0x64, 0x02, +0x38, 0xce, 0x7d, 0x87, 0xcd, 0xc6, 0xc2, 0x3f, 0x23, 0xae, 0x5b, 0xf6, +0xdd, 0x3d, 0xce, 0x2b, 0xe8, 0x09, 0x67, 0xe7, 0x2b, 0x7a, 0x64, 0xa1, +0x54, 0xb3, 0x8b, 0xaa, 0xda, 0xd1, 0x6e, 0xa7, 0xae, 0x70, 0x32, 0x5a, +0xc3, 0x4a, 0xf2, 0xb9, 0xb5, 0x11, 0x9f, 0x0a, 0x9d, 0xed, 0x09, 0xf5, +0xac, 0x41, 0x9f, 0x7f, 0x3e, 0x00, 0xb0, 0xb1, 0x98, 0x4c, 0xb2, 0xc8, +0x87, 0x0b, 0xca, 0xd5, 0xc9, 0x2b, 0x5f, 0xcb, 0x9a, 0x7c, 0x7d, 0xd3, +0xd2, 0x60, 0xf6, 0xdf, 0xd7, 0x8a, 0x0a, 0x9c, 0x0b, 0x1d, 0x4d, 0xfa, +0xee, 0xce, 0x84, 0x90, 0x54, 0x38, 0xb4, 0xfb, 0xaa, 0xee, 0xc2, 0x6b, +0xef, 0xa7, 0x64, 0x73, 0x0e, 0x6b, 0x79, 0x06, 0xfb, 0xe7, 0x3b, 0x3a, +0xb8, 0x32, 0xfe, 0x80, 0xc5, 0xc4, 0x2f, 0xca, 0x4b, 0x2c, 0x21, 0x88, +0xbd, 0x23, 0xdc, 0x10, 0x14, 0x15, 0x13, 0xbc, 0x12, 0xe3, 0x21, 0xa4, +0x78, 0x87, 0xf2, 0xf5, 0x42, 0xb1, 0x50, 0xaf, 0xa2, 0xb6, 0xf1, 0xb2, +0xe6, 0xfd, 0x5c, 0x10, 0x88, 0x89, 0x61, 0x05, 0x43, 0x87, 0x1b, 0x5a, +0xaf, 0x5a, 0xb1, 0x02, 0xa2, 0xe2, 0x61, 0x04, 0x64, 0xee, 0x5c, 0x48, +0xde, 0x85, 0xdd, 0x65, 0x3c, 0x64, 0x66, 0x17, 0xe1, 0xda, 0xbc, 0x8a, +0xd0, 0x83, 0x08, 0x85, 0xc0, 0x8a, 0xdc, 0x8e, 0xb0, 0x19, 0x89, 0x6a, +0x18, 0xc6, 0x4b, 0x98, 0x5d, 0xc7, 0x15, 0x2b, 0xee, 0x45, 0x4b, 0x05, +0xed, 0xce, 0xb9, 0x11, 0xce, 0xba, 0xb5, 0xf6, 0x2e, 0x4b, 0x37, 0xc4, +0xd3, 0x85, 0xb8, 0xc6, 0xb0, 0x53, 0xe8, 0xed, 0xa8, 0x27, 0x11, 0x8a, +0xc7, 0x2b, 0x81, 0x20, 0x51, 0x0d, 0x43, 0xc4, 0xa1, 0x7b, 0xab, 0x6d, +0x4f, 0x1d, 0xc6, 0xda, 0xb2, 0xc0, 0x43, 0x59, 0x56, 0x6c, 0x76, 0xdb, +0x49, 0xfa, 0x57, 0x1e, 0xdd, 0x9a, 0x4d, 0x2a, 0xec, 0x35, 0x7a, 0x7c, +0x22, 0x0a, 0x35, 0x8f, 0x2d, 0x9b, 0x47, 0x11, 0x13, 0x31, 0x13, 0x53, +0xb1, 0x78, 0xf5, 0xd9, 0x39, 0x0f, 0x01, 0x3d, 0x86, 0x8e, 0x66, 0x44, +0xa1, 0x2d, 0x11, 0xe2, 0xf9, 0x54, 0xdf, 0xfe, 0x1b, 0xa0, 0x39, 0x21, +0xd0, 0x1d, 0xe6, 0x63, 0x97, 0x59, 0x63, 0x82, 0x19, 0xc3, 0x7a, 0x30, +0x42, 0x4d, 0x90, 0x7a, 0x31, 0x9f, 0xec, 0x62, 0xee, 0x3e, 0x27, 0x50, +0x5f, 0x59, 0xd4, 0x72, 0x53, 0x0c, 0xc3, 0x4e, 0x89, 0x04, 0x15, 0x73, +0x70, 0x7e, 0x17, 0xaf, 0x71, 0x62, 0x16, 0x73, 0x0c, 0xc3, 0x93, 0x80, +0x31, 0xb8, 0x19, 0x11, 0x78, 0x3f, 0x89, 0xca, 0x84, 0xc1, 0x30, 0x3c, +0x09, 0x18, 0x4f, 0x0c, 0xb4, 0x5d, 0xc4, 0x82, 0x17, 0x80, 0x61, 0x98, +0xdb, 0xbe, 0xb7, 0x1a, 0x46, 0x10, 0x02, 0x42, 0x42, 0x18, 0x86, 0xed, +0x35, 0xee, 0x8b, 0xe8, 0x4b, 0x04, 0x26, 0x84, 0x00, 0xc3, 0x30, 0x04, +0x62, 0x6c, 0x21, 0x20, 0x34, 0x84, 0x61, 0x18, 0x67, 0x23, 0x06, 0xe7, +0xfd, 0x30, 0x18, 0x07, 0xc2, 0x30, 0x0c, 0xc3, 0x83, 0x18, 0xd7, 0x33, +0x98, 0x5c, 0x50, 0x3a, 0xca, 0x00, 0xc5, 0x30, 0x0c, 0x0f, 0x62, 0x60, +0x41, 0x18, 0x39, 0x44, 0x54, 0x7b, 0x7f, 0x1b, 0x0c, 0xc3, 0x1e, 0xa1, +0x6c, 0xc8, 0xc0, 0xf0, 0x82, 0xe0, 0x82, 0x2e, 0x94, 0xad, 0xdc, 0xdc, +0x85, 0x61, 0x84, 0x97, 0x20, 0x7a, 0xee, 0xc0, 0xf9, 0xce, 0x94, 0x84, +0x8b, 0x3e, 0x0e, 0x3a, 0xed, 0x30, 0xc9, 0xf3, 0xc0, 0xb0, 0xaa, 0x6d, +0x62, 0x29, 0x8f, 0x17, 0x2e, 0x9a, 0x11, 0x83, 0xd7, 0x5e, 0x83, 0xbd, +0x54, 0x1d, 0xc3, 0xb0, 0x6a, 0x8d, 0x0b, 0x84, 0xae, 0x86, 0x8b, 0xa8, +0x2c, 0x3a, 0x27, 0x0e, 0x35, 0xdf, 0xf3, 0x8b, 0x61, 0x24, 0xa6, 0x49, +0x4c, 0x1f, 0xf5, 0x10, 0x3e, 0x1c, 0x3e, 0x63, 0x10, 0x1d, 0x4f, 0x46, +0xeb, 0xd5, 0x8d, 0x88, 0x03, 0x86, 0x55, 0x9f, 0x77, 0xe0, 0xe2, 0xa0, +0x3d, 0x21, 0x23, 0x3c, 0x84, 0x38, 0x03, 0x4e, 0xc5, 0x81, 0xbc, 0x03, +0x86, 0x51, 0xb5, 0xd4, 0xb2, 0x28, 0x2c, 0x08, 0xc2, 0x35, 0x31, 0xb0, +0x57, 0x56, 0xca, 0xaf, 0x7a, 0x5f, 0xae, 0xfc, 0xca, 0x33, 0xc2, 0x30, +0xc4, 0xa1, 0xb5, 0x5c, 0xc2, 0x4c, 0xd8, 0xe8, 0x5c, 0x9c, 0x52, 0x85, +0xc0, 0x27, 0xb4, 0xa6, 0xd0, 0x35, 0x95, 0x3f, 0x47, 0x1c, 0x30, 0x8c, +0xbc, 0x03, 0xa2, 0xd0, 0xb9, 0x57, 0x60, 0x84, 0x60, 0xde, 0x19, 0xa3, +0x5c, 0x34, 0xb4, 0x84, 0x57, 0x86, 0x61, 0xf5, 0x1a, 0xf7, 0x3e, 0xf8, +0x10, 0x12, 0xa2, 0xb0, 0x5f, 0x10, 0x8c, 0x57, 0x70, 0x0a, 0xf5, 0x1e, +0xc8, 0x3b, 0x60, 0x58, 0xd5, 0x09, 0xe9, 0x79, 0x74, 0x61, 0x98, 0xd9, +0xc1, 0x7e, 0x1e, 0x18, 0x81, 0x67, 0x30, 0x9b, 0x10, 0x51, 0x8c, 0x9d, +0xc4, 0x24, 0xc2, 0x40, 0xd5, 0x12, 0x86, 0x5d, 0x9b, 0xa3, 0xb1, 0xd7, +0x2e, 0xb3, 0x01, 0x9c, 0x46, 0xf6, 0x1a, 0xa6, 0xd1, 0x2b, 0x90, 0xec, +0x00, 0x4b, 0x28, 0x04, 0x78, 0x0f, 0x18, 0x96, 0x66, 0x57, 0x7f, 0x33, +0x66, 0xef, 0x84, 0x9f, 0xb5, 0xc2, 0x52, 0x43, 0xbe, 0xfa, 0xdf, 0xb6, +0xd1, 0xa7, 0xf9, 0x73, 0x0d, 0x0b, 0xcf, 0xa9, 0xe7, 0x7d, 0x0b, 0x0c, +0x97, 0x5b, 0x58, 0x11, 0x00, 0x3b, 0x10, 0x4a, 0x0c, 0x86, 0x59, 0x0f, +0xc5, 0xe1, 0x3d, 0x60, 0x18, 0xa7, 0x97, 0xab, 0x08, 0x25, 0xf9, 0x05, +0xb2, 0xdb, 0xc5, 0x3f, 0x48, 0x12, 0x67, 0xf1, 0x04, 0xce, 0x78, 0x6e, +0x2a, 0x0e, 0x54, 0x2e, 0x61, 0x18, 0x8d, 0xf1, 0x6a, 0x61, 0xe9, 0x68, +0xf7, 0x3f, 0x19, 0x97, 0xb2, 0x29, 0xe4, 0xe7, 0x10, 0x71, 0x10, 0xa3, +0x53, 0x2b, 0x86, 0x1d, 0xae, 0x24, 0x82, 0x14, 0xbb, 0xd6, 0x56, 0xc4, +0x20, 0xf0, 0x02, 0x26, 0xd7, 0xd7, 0x91, 0xf6, 0x77, 0xef, 0x81, 0xd2, +0x56, 0x0c, 0xa3, 0xbd, 0x05, 0x02, 0xf1, 0xe4, 0xd0, 0x49, 0xce, 0xa4, +0x70, 0x6d, 0xde, 0x03, 0xe1, 0x25, 0x0c, 0xc3, 0x7b, 0xa8, 0x26, 0x31, +0x8d, 0x57, 0x50, 0x3e, 0x07, 0x24, 0x09, 0x69, 0x15, 0x08, 0x92, 0xd3, +0x18, 0x46, 0xee, 0x61, 0x28, 0x81, 0xd8, 0x10, 0x03, 0x5e, 0xac, 0xf7, +0xe2, 0xf4, 0xdc, 0x03, 0x77, 0x3d, 0x60, 0x18, 0xde, 0x43, 0xb7, 0x02, +0xf1, 0xa4, 0xb5, 0x04, 0x62, 0xb0, 0xcd, 0x7b, 0x5b, 0x0d, 0x92, 0xd3, +0x18, 0x76, 0xc8, 0xc8, 0x3d, 0xd4, 0x2c, 0x10, 0x2b, 0x0d, 0xe7, 0x10, +0x82, 0x63, 0xdc, 0x35, 0xbc, 0x84, 0xf7, 0x80, 0x61, 0x34, 0xc8, 0xab, +0x2e, 0xbc, 0x71, 0x41, 0x14, 0x26, 0x1e, 0xdf, 0x75, 0xef, 0x81, 0x96, +0xde, 0x18, 0xc6, 0xc1, 0xb8, 0xaa, 0x17, 0xa9, 0x03, 0xf1, 0x3e, 0x44, +0x21, 0x1e, 0x24, 0xa7, 0x31, 0x8c, 0xf0, 0x52, 0xfd, 0x6c, 0xf5, 0x5e, +0xc2, 0x5b, 0x48, 0x2b, 0x10, 0xf6, 0xae, 0x69, 0x26, 0x3c, 0x86, 0x91, +0x9c, 0xae, 0x3a, 0x1e, 0xee, 0xfe, 0x9e, 0x48, 0xde, 0x7b, 0x6f, 0x01, +0x5c, 0x08, 0xef, 0xd1, 0x5a, 0x03, 0xc3, 0x38, 0x18, 0x07, 0xb0, 0xc6, +0xac, 0xe5, 0xad, 0x74, 0x6e, 0xc5, 0x30, 0x72, 0x0f, 0x00, 0x1f, 0x72, +0x3f, 0x5a, 0xde, 0x4a, 0xfe, 0x01, 0xc3, 0x76, 0x19, 0xf7, 0x3e, 0xc3, +0x18, 0x68, 0x7b, 0x0d, 0xf2, 0x0f, 0x18, 0x86, 0xe7, 0x00, 0x60, 0x79, +0x4f, 0x50, 0xf7, 0x18, 0x5e, 0x12, 0x8f, 0x08, 0xaf, 0x08, 0x8b, 0x65, +0x9c, 0x79, 0x80, 0xd1, 0x78, 0x6f, 0xaf, 0xd1, 0xd3, 0xe9, 0x69, 0x11, +0x05, 0x49, 0xb8, 0x23, 0x0e, 0x98, 0x23, 0x29, 0x0d, 0x70, 0x3e, 0xbc, +0xa4, 0xf9, 0x87, 0x5e, 0x5a, 0x7b, 0x8b, 0xd0, 0xc9, 0xcf, 0x84, 0x38, +0x60, 0x91, 0x6d, 0x62, 0xc5, 0x80, 0x91, 0x98, 0x7b, 0x2b, 0x6f, 0xe5, +0x9a, 0x54, 0xcc, 0x91, 0x94, 0x06, 0xb8, 0x9e, 0x7b, 0x90, 0x78, 0x6a, +0x4f, 0xcd, 0xf9, 0xf4, 0x34, 0x38, 0x8d, 0x06, 0x31, 0xc4, 0x01, 0xe0, +0x1a, 0xef, 0xbd, 0x97, 0x7a, 0x08, 0x2f, 0xc9, 0xe7, 0x17, 0xb1, 0xe3, +0x1c, 0x07, 0x16, 0xd9, 0xa8, 0x58, 0x82, 0xe1, 0xb8, 0xdb, 0xde, 0x4b, +0x3d, 0x84, 0x97, 0x44, 0x18, 0x38, 0x05, 0x8e, 0x21, 0x0e, 0x00, 0x17, +0x91, 0xd0, 0x92, 0xf5, 0x1e, 0x5a, 0x0f, 0xc9, 0x88, 0xd8, 0x89, 0xf7, +0xc0, 0xfd, 0xd9, 0x98, 0x23, 0x21, 0x0d, 0x70, 0x2d, 0xb4, 0xa4, 0x65, +0xad, 0x3d, 0x84, 0x97, 0xd4, 0x13, 0x22, 0xb4, 0x84, 0xc5, 0x32, 0xce, +0x3a, 0x00, 0xa1, 0x25, 0x6f, 0x2d, 0x2f, 0xac, 0x22, 0x6c, 0xe2, 0x09, +0x21, 0x0e, 0x18, 0xde, 0x03, 0xc0, 0x35, 0x26, 0x0d, 0xc5, 0xf4, 0x20, +0x0e, 0x62, 0x22, 0x0e, 0xe4, 0x1d, 0xba, 0x39, 0x80, 0x46, 0xde, 0x01, +0xa0, 0x10, 0xb3, 0x15, 0x07, 0xf9, 0xb5, 0xf5, 0xbc, 0x83, 0x08, 0x03, +0xbd, 0xa3, 0x10, 0x88, 0x98, 0xc6, 0xdd, 0x0e, 0x30, 0xac, 0xe7, 0x60, +0x2b, 0x96, 0x5a, 0x3f, 0x44, 0xa6, 0x09, 0x76, 0x0e, 0xc3, 0x21, 0x10, +0x91, 0x3f, 0x03, 0xf7, 0xd8, 0xc3, 0x98, 0xe2, 0xd0, 0x43, 0xeb, 0x09, +0xcd, 0x39, 0x70, 0x18, 0xae, 0xbf, 0x86, 0x8a, 0x78, 0x0f, 0x00, 0x79, +0x59, 0x34, 0xac, 0xd4, 0x43, 0x12, 0x57, 0x0f, 0xc2, 0x51, 0xb1, 0xd4, +0x9f, 0x89, 0xd8, 0x57, 0x20, 0x12, 0x9c, 0x96, 0x86, 0x71, 0xc4, 0x41, +0x26, 0x5d, 0x2f, 0xdd, 0x4c, 0x6d, 0xfe, 0x84, 0xa4, 0x74, 0x9f, 0x02, +0x51, 0xd2, 0x23, 0xc4, 0x7b, 0x80, 0xe1, 0x3c, 0x87, 0x5e, 0xe2, 0xf3, +0xda, 0x7c, 0x0f, 0xcf, 0x01, 0x81, 0x48, 0x68, 0xb4, 0xf0, 0x86, 0xee, +0xb9, 0xcb, 0x01, 0x1f, 0x11, 0x86, 0x5e, 0x4e, 0x14, 0xdb, 0xd3, 0xde, +0x78, 0x0e, 0x7d, 0x0b, 0x44, 0x29, 0xf1, 0xc7, 0x7b, 0x80, 0x11, 0xb8, +0xf5, 0x24, 0x0e, 0x36, 0x19, 0x6d, 0x2b, 0xaf, 0xa8, 0x5a, 0xea, 0x57, +0x20, 0x0a, 0x96, 0x2c, 0x4f, 0x2c, 0x1f, 0xd0, 0xb5, 0x38, 0xc8, 0x2e, +0xa8, 0x97, 0x05, 0x74, 0xed, 0x30, 0x9f, 0x0d, 0x33, 0xe9, 0xc9, 0x69, +0xfa, 0x2e, 0xd5, 0x2d, 0xf0, 0x3a, 0x1e, 0x43, 0xab, 0x49, 0x20, 0xf0, +0x1e, 0x60, 0x88, 0xb0, 0x92, 0x2c, 0x98, 0xbd, 0x88, 0xc3, 0xda, 0x79, +0x0d, 0xf9, 0x55, 0xbb, 0xb5, 0xda, 0x36, 0x21, 0xf2, 0xff, 0xb2, 0xb8, +0x20, 0x16, 0x65, 0xdf, 0x99, 0x16, 0x44, 0x58, 0x93, 0x05, 0xff, 0x95, +0xe9, 0xdf, 0xd5, 0x0d, 0x40, 0x81, 0xf7, 0x88, 0xf7, 0x00, 0xfd, 0x87, +0x95, 0x7a, 0x38, 0xdf, 0x60, 0x1b, 0x08, 0x3e, 0x8b, 0x47, 0xab, 0x58, +0x58, 0x2f, 0xc3, 0x7a, 0x16, 0x3d, 0xe5, 0x60, 0x6a, 0x14, 0x03, 0x6b, +0x9a, 0x5c, 0x56, 0x2f, 0x6f, 0xcf, 0x38, 0x0c, 0xbf, 0x86, 0xbe, 0xb3, +0x42, 0x67, 0x5b, 0x68, 0xab, 0x01, 0x7d, 0xe2, 0xdd, 0xe3, 0x6e, 0xe2, +0xcf, 0x36, 0x9c, 0x74, 0x64, 0xc1, 0x92, 0x7f, 0xf3, 0x4c, 0x30, 0x2a, +0xa9, 0xb1, 0x6f, 0xbe, 0xbb, 0xa9, 0x98, 0x1f, 0x73, 0xb2, 0xa8, 0xce, +0xde, 0x64, 0x07, 0x7e, 0xd7, 0x30, 0xe7, 0x55, 0xcf, 0xb1, 0x50, 0xa2, +0x9a, 0xf3, 0x0f, 0xd0, 0x1d, 0x4b, 0x2f, 0xc2, 0xa0, 0x07, 0xf9, 0xae, +0x2e, 0xe2, 0x1a, 0xf7, 0x5e, 0x0b, 0x45, 0xf5, 0x2c, 0x18, 0xcf, 0xe2, +0xfd, 0xaf, 0x62, 0xff, 0xe1, 0xd7, 0x59, 0x11, 0x81, 0x77, 0x01, 0xd8, +0x31, 0x26, 0xe7, 0x2b, 0x3f, 0x83, 0x9e, 0xf6, 0x2f, 0x21, 0x7e, 0x8e, +0x16, 0x1b, 0x80, 0x38, 0xd4, 0x15, 0xaf, 0x4e, 0xdd, 0x30, 0x30, 0xfc, +0x5e, 0xa1, 0x60, 0x68, 0x0c, 0x5c, 0x05, 0xa3, 0xd6, 0xb0, 0x54, 0x18, +0xd2, 0x51, 0x01, 0x54, 0x71, 0x0d, 0x7f, 0x1e, 0x35, 0x2b, 0x86, 0x62, +0xd6, 0x0b, 0x50, 0x33, 0x9e, 0xc0, 0x3d, 0xc2, 0x22, 0x39, 0x5d, 0xf9, +0x39, 0x35, 0xc4, 0x58, 0x48, 0xbc, 0x09, 0x35, 0x41, 0x1f, 0x39, 0x87, +0x56, 0x85, 0x41, 0x17, 0x80, 0x52, 0x9d, 0x64, 0x6d, 0xcc, 0x3b, 0x5c, +0x5c, 0xd7, 0x16, 0x59, 0x8d, 0xaf, 0xab, 0x5d, 0xcd, 0xf5, 0xac, 0xed, +0xf4, 0xed, 0xd7, 0xd7, 0x50, 0x59, 0x98, 0xe4, 0xd5, 0xcf, 0x65, 0x3f, +0x9b, 0x2e, 0xfe, 0xfa, 0xb9, 0xc2, 0xc5, 0x3f, 0xf2, 0xc2, 0xbf, 0x9b, +0x2b, 0xe3, 0xd3, 0xf6, 0x0c, 0xcb, 0x2d, 0xd6, 0x34, 0xea, 0x03, 0x72, +0x0e, 0x85, 0x84, 0xc1, 0x86, 0x7b, 0x4a, 0x9e, 0x84, 0xf6, 0x8b, 0xc0, +0xe4, 0x6d, 0xd1, 0xd2, 0x60, 0x5d, 0x68, 0xd7, 0x16, 0xe6, 0x35, 0x0b, +0x17, 0xeb, 0x3d, 0x76, 0xe4, 0xeb, 0x85, 0x3b, 0x7f, 0xb1, 0x27, 0xbb, +0xfe, 0x7b, 0x65, 0x0b, 0xdb, 0xec, 0x22, 0x54, 0xb1, 0x95, 0x10, 0x09, +0x4a, 0x5e, 0xa1, 0x65, 0x66, 0xd7, 0x58, 0x7e, 0xc1, 0x0a, 0x43, 0xe9, +0x4e, 0xb2, 0x7e, 0x67, 0xbb, 0xd5, 0x4e, 0xe1, 0xee, 0x45, 0x63, 0xd6, +0x45, 0x58, 0x77, 0xe4, 0x6b, 0x02, 0xf2, 0xac, 0x84, 0xf3, 0x95, 0x88, +0xd8, 0xc5, 0xdf, 0x2e, 0xfa, 0x2b, 0xc9, 0xdf, 0x1a, 0x17, 0xff, 0x3d, +0xdc, 0x63, 0x6c, 0x2a, 0x4a, 0xe5, 0x23, 0x1c, 0x65, 0xaf, 0x40, 0xce, +0x21, 0xdf, 0x21, 0x37, 0x4d, 0x0e, 0x97, 0x8c, 0xef, 0x47, 0x48, 0x42, +0xde, 0xcd, 0xc2, 0xbd, 0xa8, 0x78, 0x88, 0xc9, 0xcf, 0x15, 0xda, 0x5a, +0xac, 0xdf, 0xec, 0xfc, 0xa7, 0xce, 0x43, 0x19, 0xb7, 0x18, 0xef, 0x5a, +0xcf, 0x45, 0xe4, 0x6e, 0xaf, 0xc2, 0x5d, 0xd4, 0xd0, 0x1a, 0x77, 0xd7, +0x58, 0xa9, 0xaa, 0xdd, 0x45, 0x97, 0xbe, 0xb3, 0xc1, 0x2f, 0xcc, 0x29, +0x17, 0xe4, 0xdb, 0x8a, 0xb1, 0xa1, 0x89, 0x78, 0x68, 0xb2, 0xc0, 0x18, +0xa2, 0xec, 0x15, 0xda, 0xd8, 0x8d, 0xd5, 0x9c, 0x94, 0x96, 0x9d, 0xe2, +0x9a, 0x30, 0x54, 0xe4, 0x35, 0x10, 0x2e, 0x28, 0xc3, 0x14, 0xdb, 0x23, +0xcd, 0x15, 0x9e, 0x54, 0x0f, 0x90, 0x57, 0x08, 0x84, 0x96, 0x12, 0x08, +0x43, 0x25, 0x77, 0x5d, 0x2f, 0xec, 0xe4, 0xfb, 0xf1, 0x7a, 0xed, 0x69, +0x6b, 0x47, 0xd9, 0x2b, 0xc0, 0xbf, 0xd4, 0xe8, 0x3d, 0x3c, 0xf3, 0x18, +0x4a, 0x1f, 0x3e, 0xf3, 0xe1, 0x24, 0xfa, 0xfa, 0x77, 0x3a, 0x76, 0x73, +0x1e, 0x70, 0xa4, 0xec, 0x15, 0xaa, 0x0f, 0x2f, 0xd5, 0x74, 0x70, 0x2b, +0x4c, 0x3e, 0xdb, 0x73, 0x02, 0x15, 0x54, 0x27, 0x2d, 0x84, 0x93, 0xc6, +0xf0, 0x7e, 0x73, 0xce, 0x09, 0xca, 0x5e, 0xa1, 0x66, 0x26, 0x57, 0xd1, +0x39, 0x06, 0xdb, 0x08, 0xcf, 0x94, 0x64, 0x66, 0x0d, 0x81, 0x05, 0x6d, +0x20, 0x26, 0xbc, 0x05, 0xc6, 0x2f, 0xa1, 0x26, 0x18, 0x92, 0xd2, 0x87, +0xe2, 0xac, 0x30, 0xf8, 0x9c, 0x82, 0x2e, 0xca, 0xd6, 0xed, 0xbe, 0x27, +0xfe, 0x9c, 0xf6, 0x3c, 0x00, 0x62, 0xd0, 0x16, 0xc9, 0xaa, 0xef, 0xb4, +0xbc, 0x38, 0xe3, 0x7c, 0x60, 0xec, 0x41, 0x5d, 0x94, 0xca, 0x3f, 0x68, +0xdb, 0x6d, 0xd3, 0x55, 0x75, 0x71, 0xcf, 0x0f, 0x98, 0x2d, 0xa9, 0x26, +0x2b, 0x2e, 0x3e, 0x21, 0xd2, 0x27, 0x1b, 0x87, 0x29, 0x97, 0x48, 0xd0, +0xcc, 0x0f, 0x46, 0x9a, 0x5c, 0x2f, 0xef, 0x05, 0x36, 0xc2, 0xb0, 0x6b, +0xa7, 0x98, 0x58, 0xcc, 0xd8, 0xbd, 0xe1, 0x05, 0x6f, 0x85, 0x7d, 0xee, +0x19, 0x37, 0x52, 0x84, 0x9a, 0xa0, 0x1a, 0xa6, 0x12, 0xe1, 0x24, 0xdf, +0x27, 0x69, 0x39, 0xb1, 0x28, 0x27, 0xfb, 0xbc, 0x78, 0x11, 0x8c, 0xe3, +0x17, 0x8b, 0xf5, 0x2d, 0x47, 0x38, 0xd6, 0xf4, 0xf1, 0x02, 0x28, 0x4e, +0xb6, 0xbe, 0x4b, 0x5a, 0xb6, 0xea, 0xbd, 0x86, 0x2b, 0x13, 0x20, 0x65, +0xd5, 0x0a, 0xee, 0x3d, 0x9e, 0xf0, 0xab, 0xdd, 0x7c, 0xf2, 0x82, 0x09, +0xff, 0xb3, 0xe0, 0xd1, 0x42, 0x59, 0x72, 0xb9, 0xcd, 0xda, 0x5a, 0x3a, +0xd6, 0xa9, 0xe3, 0x84, 0x9f, 0x9b, 0x49, 0xc9, 0x58, 0xde, 0x13, 0xee, +0x49, 0xbe, 0xb1, 0xc2, 0xa3, 0x85, 0xd2, 0x64, 0xe9, 0xbd, 0xa4, 0x89, +0x68, 0x17, 0x37, 0xb6, 0x9a, 0x2a, 0xa4, 0x40, 0x6f, 0x9c, 0x46, 0x49, +0x14, 0xfe, 0x79, 0x36, 0x66, 0xe7, 0x0c, 0xf9, 0x3b, 0xc6, 0x23, 0xf4, +0x1b, 0x5e, 0x4a, 0x24, 0x0e, 0xc9, 0x5c, 0x7d, 0x76, 0x6d, 0x8c, 0x67, +0x77, 0x2c, 0x61, 0x3c, 0xa5, 0xf4, 0xc2, 0x09, 0x7b, 0x42, 0xb7, 0x02, +0x61, 0xaa, 0x94, 0x52, 0xed, 0x82, 0xee, 0xb1, 0x77, 0x70, 0x34, 0x4f, +0xc3, 0x23, 0x76, 0xc7, 0x2b, 0x8a, 0x52, 0x27, 0xaf, 0xa9, 0x6a, 0x82, +0x7e, 0x04, 0x42, 0xcf, 0x37, 0xf8, 0xb6, 0x18, 0x53, 0xe2, 0x9f, 0x21, +0x45, 0xc2, 0x90, 0x3c, 0x44, 0x9b, 0xa4, 0x48, 0x54, 0x1f, 0x59, 0x9c, +0x53, 0x86, 0x9c, 0x18, 0x93, 0x90, 0x97, 0x14, 0xbb, 0x1e, 0xbd, 0x15, +0x2d, 0xe3, 0x81, 0x9f, 0x14, 0xbb, 0xc6, 0x89, 0xd1, 0x81, 0x40, 0x9c, +0xdc, 0xbd, 0x27, 0x39, 0x2f, 0x41, 0xe8, 0x13, 0x9a, 0x77, 0xc7, 0xb5, +0x55, 0x72, 0x86, 0x8b, 0x73, 0x52, 0x0b, 0x1d, 0x2e, 0x7d, 0xa3, 0x24, +0x58, 0x9c, 0xcf, 0x8c, 0x85, 0x5b, 0x22, 0xcf, 0x96, 0x8d, 0x0b, 0xb4, +0x19, 0x5e, 0x0a, 0xc4, 0x21, 0x37, 0x13, 0xbb, 0x35, 0xf0, 0xc4, 0x5e, +0x98, 0xaf, 0x6c, 0x16, 0xa2, 0x86, 0x9c, 0x18, 0x97, 0xd0, 0xa4, 0x40, +0x14, 0x16, 0x87, 0xe8, 0xa1, 0x05, 0x2a, 0x47, 0xf0, 0x8c, 0x23, 0x7a, +0x93, 0xd1, 0x6e, 0x6a, 0x64, 0x5c, 0x42, 0x93, 0x3b, 0x2d, 0x9f, 0x8c, +0x5e, 0x7a, 0xf9, 0x79, 0x98, 0x88, 0x4d, 0x13, 0x3b, 0x0f, 0x11, 0x63, +0x5c, 0xc7, 0xf4, 0x70, 0x39, 0x17, 0x01, 0xe9, 0x77, 0x59, 0x91, 0x27, +0xd1, 0xdc, 0xd3, 0xcf, 0x44, 0x9b, 0x83, 0xb6, 0x89, 0x9c, 0x87, 0xb8, +0x2a, 0x10, 0xf7, 0x98, 0xa1, 0x26, 0xc2, 0x4c, 0xd0, 0x4c, 0x78, 0xa9, +0xb6, 0xa6, 0x62, 0x91, 0x93, 0xd5, 0x08, 0x04, 0xde, 0xf1, 0x59, 0x81, +0x78, 0xdc, 0x5d, 0x92, 0xe2, 0x2e, 0x09, 0x04, 0x02, 0x9a, 0x58, 0x48, +0x2b, 0xed, 0x38, 0x89, 0x2b, 0x0f, 0xba, 0x6b, 0x2f, 0x21, 0x10, 0x8f, +0xea, 0xa5, 0x94, 0xed, 0x37, 0x38, 0xc8, 0x09, 0xa9, 0x89, 0x15, 0xa3, +0x9d, 0x6a, 0xfc, 0xe1, 0x22, 0x4e, 0x4e, 0x4a, 0x5d, 0x1b, 0xa6, 0xc0, +0x38, 0xc8, 0x72, 0x5f, 0x04, 0x02, 0x01, 0x2d, 0xec, 0xb2, 0xab, 0xdd, +0x5d, 0x47, 0x0c, 0x33, 0x21, 0x10, 0x84, 0x99, 0xf6, 0x8e, 0xf5, 0x39, +0xd7, 0xa5, 0x5b, 0x84, 0x98, 0xa0, 0xea, 0x89, 0xd3, 0xc0, 0x0e, 0x26, +0x56, 0x98, 0x09, 0x81, 0x20, 0xcc, 0xb4, 0x67, 0x1c, 0x64, 0xbb, 0x4f, +0xc5, 0x71, 0x58, 0x0e, 0x1a, 0x08, 0x2f, 0x55, 0xbf, 0x70, 0x46, 0x72, +0xf5, 0x11, 0x88, 0xc6, 0x89, 0x31, 0x0e, 0x5e, 0x6d, 0x88, 0x72, 0xdc, +0x30, 0x47, 0x78, 0x09, 0x5a, 0x72, 0xbb, 0x5b, 0xa8, 0xee, 0x89, 0xb1, +0xab, 0x43, 0x20, 0x1a, 0x27, 0xe2, 0xe2, 0x7d, 0x2f, 0xed, 0x3d, 0x50, +0x7a, 0x0d, 0xd5, 0xef, 0xa8, 0x5a, 0xda, 0xc1, 0x5c, 0xf5, 0x94, 0x88, +0xf5, 0xb2, 0x21, 0x7a, 0x11, 0xd6, 0xb9, 0xe5, 0xca, 0x3b, 0xf8, 0xef, +0x43, 0x55, 0x1d, 0x54, 0xef, 0x72, 0x37, 0xb3, 0xab, 0xbe, 0xba, 0x7b, +0x44, 0x20, 0xba, 0x60, 0x72, 0xe9, 0x12, 0xd5, 0xb1, 0xbe, 0x76, 0x8b, +0xe5, 0xe4, 0xd0, 0x21, 0xb7, 0xc1, 0xc2, 0x2e, 0x97, 0x26, 0x30, 0x02, +0xc1, 0xa6, 0xa8, 0xb4, 0x40, 0x20, 0x0e, 0x90, 0x55, 0x20, 0x46, 0x48, +0x50, 0xc7, 0x0a, 0x33, 0x21, 0x10, 0x7d, 0x10, 0x29, 0x0f, 0xb1, 0x26, +0x10, 0x49, 0xef, 0x73, 0xf7, 0xc2, 0x46, 0xce, 0x01, 0xb2, 0x31, 0x5c, +0xe2, 0xf6, 0xca, 0xe2, 0x80, 0x40, 0x30, 0xee, 0x5f, 0x8d, 0xfb, 0x54, +0x07, 0xe3, 0x18, 0x7b, 0xd0, 0xea, 0x4e, 0x6a, 0x19, 0x68, 0x71, 0x20, +0x29, 0xd8, 0x07, 0xf7, 0x84, 0xe3, 0x3e, 0x6a, 0x98, 0xc9, 0x0b, 0x0e, +0x21, 0x25, 0x68, 0x32, 0xbc, 0xd4, 0xa2, 0x40, 0x5c, 0x59, 0x1c, 0x70, +0xef, 0x3b, 0x21, 0xc2, 0x4e, 0x7f, 0x4e, 0x39, 0xaf, 0xfc, 0xe6, 0x0d, +0x61, 0x80, 0x72, 0x02, 0xe1, 0x06, 0x3d, 0x5d, 0x7c, 0x66, 0x71, 0xe0, +0x40, 0x12, 0xde, 0xf3, 0x81, 0x90, 0xcf, 0xe1, 0x1e, 0x4c, 0x22, 0x2a, +0xfe, 0x6b, 0xce, 0x6c, 0x44, 0xa0, 0x1b, 0x81, 0x68, 0x74, 0xe1, 0x3c, +0x53, 0x0b, 0x4f, 0x78, 0xa9, 0x2f, 0x2e, 0xe5, 0x21, 0x76, 0x5e, 0x20, +0x75, 0xf7, 0x36, 0x19, 0xbb, 0x07, 0xbf, 0xaf, 0xff, 0xcd, 0x65, 0x54, +0xd0, 0x65, 0x88, 0xa9, 0xc5, 0x5e, 0x30, 0x13, 0xde, 0x03, 0xe3, 0x3f, +0xc2, 0xf8, 0x27, 0x04, 0x04, 0xb8, 0xd9, 0x1d, 0x2e, 0xa0, 0x47, 0x17, +0x07, 0x16, 0x02, 0xc6, 0x3f, 0x95, 0x45, 0xc0, 0x04, 0x71, 0x63, 0xe4, +0x22, 0x76, 0x0b, 0x04, 0x8b, 0x40, 0xd7, 0x5c, 0x6e, 0xbb, 0xc1, 0xf8, +0x00, 0x26, 0x48, 0x7f, 0x71, 0xfa, 0x5d, 0x02, 0xc1, 0xe4, 0xef, 0x9e, +0x28, 0x07, 0xdb, 0x18, 0x27, 0xc0, 0x04, 0xe9, 0x4c, 0x24, 0x5e, 0x79, +0x4f, 0x3b, 0x93, 0x90, 0xd0, 0x38, 0xb1, 0x0e, 0xb6, 0x21, 0x12, 0xc0, +0x04, 0xf1, 0x0b, 0xe7, 0xf7, 0xef, 0xdf, 0xff, 0x71, 0xed, 0xb7, 0x20, +0xbe, 0x6d, 0x89, 0x04, 0xfd, 0x6e, 0xf0, 0xa2, 0x11, 0x09, 0x00, 0x77, +0x3c, 0x0f, 0x21, 0xe2, 0xb0, 0x2c, 0xcb, 0xdb, 0xcf, 0x9f, 0x3f, 0xdf, +0xb6, 0x84, 0xa2, 0xb1, 0xdd, 0xf7, 0x2c, 0x22, 0x29, 0x9f, 0x59, 0x8c, +0x93, 0xab, 0xc3, 0x11, 0xf5, 0xfe, 0x06, 0x3f, 0x9f, 0x38, 0xc7, 0x00, +0x63, 0x4f, 0x10, 0x11, 0x89, 0xdf, 0xbf, 0x7f, 0xbf, 0xfd, 0xf8, 0xf1, +0x63, 0xcb, 0x9b, 0x68, 0xed, 0x00, 0xdd, 0x8d, 0x89, 0x3d, 0x24, 0xf7, +0xd8, 0x77, 0x38, 0x70, 0x57, 0x03, 0x0c, 0xed, 0x45, 0xa8, 0x89, 0x17, +0xb1, 0x25, 0x12, 0x9c, 0x1d, 0x80, 0x56, 0x48, 0xd5, 0x60, 0xcf, 0x71, +0x03, 0x21, 0x74, 0xc2, 0x74, 0x76, 0xa7, 0x24, 0x02, 0x21, 0x42, 0xe1, +0x88, 0xc7, 0x42, 0xbb, 0xc4, 0xae, 0xe6, 0xa3, 0x7f, 0x17, 0x30, 0x49, +0x9c, 0x09, 0x35, 0x85, 0x6e, 0x3a, 0x1e, 0x04, 0xf4, 0xbe, 0x41, 0x72, +0x24, 0xae, 0x61, 0x20, 0x4e, 0xc5, 0x62, 0x25, 0x51, 0xfd, 0xeb, 0xd7, +0xaf, 0x4f, 0x02, 0xc1, 0xc4, 0x80, 0x96, 0x88, 0x7c, 0x68, 0x94, 0x72, +0x69, 0xc0, 0x8b, 0x78, 0x26, 0x10, 0xb8, 0xd6, 0x80, 0x17, 0xc1, 0x5c, +0x80, 0xbe, 0xb8, 0x1d, 0x4d, 0xd8, 0xa9, 0x40, 0xe0, 0x3d, 0x40, 0xeb, +0xa4, 0x48, 0x56, 0x37, 0x74, 0x2e, 0x08, 0x60, 0x17, 0x87, 0x7a, 0xd9, +0x4b, 0x0e, 0x42, 0xcc, 0x71, 0xfb, 0x15, 0xe0, 0x45, 0xe0, 0x41, 0xc0, +0x50, 0x93, 0x65, 0x91, 0x45, 0xdf, 0x9a, 0xee, 0x8a, 0xf4, 0x70, 0x99, +0x78, 0x10, 0xfe, 0xf7, 0xa5, 0xee, 0x9b, 0x58, 0x2b, 0xb4, 0xce, 0x1c, +0xfb, 0x5c, 0x04, 0x9b, 0x26, 0x18, 0xca, 0xc3, 0x30, 0x42, 0x70, 0x73, +0x5c, 0x76, 0x02, 0x7d, 0x8e, 0xf1, 0xc9, 0xdb, 0xbc, 0x61, 0x8b, 0x84, +0x52, 0xc5, 0xc2, 0x4d, 0x94, 0x35, 0x1f, 0x6e, 0x65, 0x7e, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x63, 0xdc, 0x78, 0x04, +0x00, 0x00, 0xb0, 0xc6, 0xcc, 0x23, 0x00, 0x00, 0x80, 0x90, 0xfb, 0xd7, +0xaf, 0x5f, 0xff, 0xc3, 0x63, 0x00, 0x00, 0x80, 0x0f, 0x78, 0x71, 0xc0, +0x83, 0x00, 0x00, 0x80, 0x4f, 0xe2, 0xf0, 0x26, 0x5e, 0x04, 0x4f, 0x03, +0x00, 0x00, 0x42, 0x71, 0x40, 0x20, 0x00, 0x00, 0xe0, 0xc1, 0xdd, 0x8a, +0xc3, 0xb7, 0x6f, 0xdf, 0xfe, 0xe7, 0xa8, 0x62, 0x02, 0x00, 0x18, 0x5b, +0x18, 0xfe, 0xd8, 0xe2, 0x05, 0x41, 0x3d, 0x87, 0xb7, 0x2f, 0x5f, 0xbe, +0xfc, 0x97, 0x47, 0x03, 0x00, 0x30, 0x26, 0xb3, 0x17, 0x81, 0xb7, 0x0d, +0x23, 0x41, 0x0d, 0x00, 0x30, 0x10, 0x93, 0x78, 0x0b, 0x2f, 0x84, 0x41, +0x6d, 0xe2, 0x71, 0x01, 0x00, 0x0c, 0x20, 0x0c, 0x41, 0xf2, 0xf9, 0xa9, +0x91, 0x7f, 0x00, 0x00, 0xe8, 0x9b, 0xfb, 0x01, 0x6f, 0x21, 0xb4, 0x85, +0xc7, 0x07, 0x00, 0xd0, 0x1f, 0xb2, 0xf3, 0xff, 0x94, 0x74, 0x3e, 0xe8, +0x3d, 0x50, 0xde, 0x0a, 0x00, 0xd0, 0x19, 0xd3, 0x49, 0x8f, 0xe1, 0xdd, +0x68, 0xaf, 0x01, 0x00, 0xd0, 0x9f, 0xd7, 0x30, 0x5f, 0x11, 0x06, 0xc7, +0xe1, 0x38, 0x00, 0x80, 0xee, 0x98, 0xcf, 0x86, 0x93, 0x1c, 0xc9, 0x69, +0x00, 0x80, 0x3e, 0xbd, 0x06, 0x09, 0x27, 0xc5, 0x12, 0x07, 0x97, 0x3e, +0x39, 0x2d, 0xc2, 0x33, 0xf1, 0xda, 0x00, 0x00, 0xd2, 0x72, 0x17, 0x71, +0xf8, 0xf1, 0xe3, 0xc7, 0x3f, 0x91, 0x05, 0x22, 0x65, 0x78, 0x69, 0x22, +0xbf, 0x01, 0x00, 0x90, 0x96, 0xf9, 0xfb, 0xf7, 0xef, 0xff, 0xfc, 0xfc, +0xf9, 0xf3, 0x4d, 0x7e, 0x8d, 0x25, 0x0e, 0x89, 0x16, 0xef, 0x9b, 0x0a, +0x83, 0x4f, 0x9e, 0xe3, 0x41, 0x00, 0x00, 0xa4, 0x14, 0x87, 0x5f, 0xbf, +0x7e, 0xbd, 0x89, 0xf7, 0x10, 0x4b, 0x1c, 0xe4, 0x6b, 0x2e, 0xcb, 0xb2, +0x16, 0x62, 0x7a, 0x5f, 0xdc, 0xc5, 0x53, 0x11, 0x93, 0xff, 0x96, 0xdf, +0xb3, 0xe6, 0xfe, 0x4d, 0x90, 0xcf, 0xe6, 0xff, 0x17, 0xf9, 0x35, 0xf0, +0x6e, 0xc8, 0x6d, 0x00, 0x00, 0x24, 0x62, 0x91, 0x85, 0xfc, 0xf7, 0xef, +0xdf, 0x6f, 0x7e, 0x31, 0x8f, 0x26, 0x0e, 0x22, 0x38, 0xf2, 0x75, 0xe5, +0x57, 0x2f, 0x12, 0x97, 0xcb, 0x65, 0x1d, 0x8d, 0xff, 0x00, 0x00, 0xf2, +0x79, 0x0e, 0xb2, 0x88, 0x4b, 0x68, 0xc9, 0xc5, 0xcb, 0x39, 0x3c, 0x04, +0x42, 0x4c, 0x3c, 0x12, 0x11, 0x88, 0xd8, 0xde, 0x89, 0xa3, 0xaf, 0x13, +0x00, 0x40, 0x32, 0x1e, 0x09, 0x69, 0x5d, 0xbc, 0x63, 0xe6, 0x1d, 0xd6, +0x4c, 0xbc, 0x93, 0x98, 0x42, 0x84, 0xf7, 0x00, 0x00, 0x90, 0x08, 0x89, +0xe5, 0xeb, 0xa2, 0x1d, 0x33, 0xb4, 0xf4, 0xcc, 0xc4, 0x83, 0xd0, 0x90, +0x53, 0x84, 0x2a, 0x29, 0xbc, 0x07, 0x00, 0x80, 0x94, 0xe2, 0x10, 0x3b, +0xb4, 0xb4, 0x57, 0x24, 0x2e, 0x86, 0x9b, 0x68, 0xfa, 0x07, 0x00, 0x90, +0x80, 0xf7, 0xbc, 0x83, 0x58, 0xea, 0xd0, 0xd2, 0x96, 0x48, 0x9c, 0x0d, +0x6b, 0x71, 0xe6, 0x01, 0x00, 0x20, 0x0d, 0x93, 0xad, 0x2e, 0x4a, 0x90, +0x34, 0x3e, 0x94, 0x93, 0xf0, 0xd5, 0x4d, 0x74, 0x84, 0x05, 0x00, 0x28, +0xcc, 0x23, 0x29, 0x2d, 0x21, 0xa5, 0x9c, 0x79, 0x87, 0x67, 0x26, 0x9f, +0xe5, 0xe0, 0xe7, 0xe0, 0xba, 0x52, 0x00, 0x80, 0xc8, 0xdc, 0x64, 0xf7, +0xad, 0xe2, 0x90, 0x3b, 0xef, 0xf0, 0xcc, 0x23, 0x90, 0xcf, 0xf2, 0x2a, +0x61, 0xed, 0xff, 0x7c, 0xe2, 0x35, 0x02, 0x00, 0xc4, 0xe5, 0x71, 0x38, +0xad, 0x54, 0x52, 0xda, 0xed, 0x38, 0x2f, 0xf1, 0x2c, 0xd4, 0x45, 0x58, +0x09, 0x00, 0x20, 0x0d, 0xb3, 0xf5, 0x1c, 0x6a, 0x08, 0x2b, 0x6d, 0x89, +0x84, 0xdb, 0x4e, 0x48, 0xd3, 0x4a, 0x03, 0x00, 0x20, 0xb6, 0xe7, 0xa0, +0xcd, 0xf7, 0x12, 0x9d, 0x62, 0x8e, 0x1e, 0x6e, 0xb2, 0x3d, 0x97, 0xf0, +0x1a, 0x00, 0x00, 0xe2, 0x73, 0x53, 0xcf, 0x41, 0x04, 0x22, 0x72, 0xdb, +0xee, 0xa4, 0x02, 0x81, 0x28, 0x00, 0x00, 0x24, 0x16, 0x86, 0x16, 0x04, +0x61, 0x43, 0x20, 0x38, 0x00, 0x07, 0x00, 0x10, 0x51, 0x14, 0xa6, 0x96, +0x84, 0xe1, 0xd9, 0xe1, 0x38, 0xfa, 0x2b, 0x01, 0x00, 0x44, 0x10, 0x84, +0x04, 0xd7, 0x82, 0x66, 0x3b, 0xfb, 0xf0, 0x22, 0x1f, 0x42, 0x98, 0x09, +0x00, 0xe0, 0x20, 0x51, 0xef, 0x52, 0x70, 0xf9, 0xc3, 0x47, 0x8f, 0xff, +0xde, 0x91, 0x30, 0xe7, 0x30, 0x1c, 0x00, 0xc0, 0x0e, 0x64, 0x37, 0xbd, +0xb4, 0x2c, 0x0c, 0x22, 0x08, 0x5a, 0x5e, 0x2b, 0xff, 0xbf, 0xa3, 0xc5, +0x07, 0x79, 0x08, 0x00, 0x80, 0x2d, 0x51, 0x30, 0x77, 0x2d, 0xbf, 0xb5, +0x6a, 0xb6, 0xe7, 0x93, 0x1e, 0xce, 0xd3, 0x4e, 0xae, 0xcf, 0xce, 0x63, +0xd0, 0x8c, 0x0f, 0x00, 0xe0, 0x33, 0x73, 0xeb, 0xa2, 0x10, 0x7a, 0x0e, +0xda, 0x31, 0x56, 0x05, 0x42, 0x4f, 0x73, 0x3f, 0x6b, 0xd2, 0xe7, 0xc3, +0x51, 0x1c, 0x8e, 0x03, 0x80, 0xe1, 0xb9, 0xb5, 0x1c, 0x42, 0xda, 0xf2, +0x1c, 0xb4, 0x09, 0x9f, 0x0a, 0x84, 0x86, 0x94, 0xec, 0xef, 0xbd, 0x68, +0xf5, 0x4d, 0x1e, 0x02, 0x00, 0xc6, 0x0e, 0x23, 0xb5, 0x7a, 0x66, 0xe1, +0x95, 0x38, 0xa8, 0x00, 0x88, 0x20, 0xd8, 0x70, 0x92, 0xf5, 0x2a, 0x9e, +0xfd, 0xec, 0x84, 0x99, 0x00, 0x60, 0x44, 0x26, 0xbf, 0xf8, 0xbd, 0xf5, +0x66, 0x5b, 0x61, 0xa5, 0xad, 0x3f, 0xe7, 0x3c, 0x04, 0x00, 0x40, 0xe7, +0xc2, 0xe0, 0x82, 0xab, 0x44, 0xad, 0x59, 0x11, 0x38, 0x22, 0x10, 0xde, +0xbb, 0x00, 0x00, 0x40, 0x18, 0x7a, 0x09, 0x2f, 0x59, 0x01, 0xd0, 0x64, +0xb4, 0x15, 0x82, 0x83, 0x02, 0xc1, 0x81, 0x39, 0x00, 0xe8, 0x92, 0xfb, +0x28, 0xc2, 0xe0, 0x56, 0x72, 0x10, 0xa1, 0x50, 0x48, 0x1e, 0x42, 0x73, +0x13, 0x2a, 0x1c, 0x3b, 0xf2, 0x2f, 0x9c, 0x87, 0x00, 0x88, 0xc8, 0xcd, +0xef, 0xba, 0xee, 0x8e, 0x32, 0xc1, 0xa2, 0x5e, 0xc3, 0xd1, 0xe4, 0xb3, +0x2c, 0xac, 0x9a, 0xd4, 0x95, 0x85, 0x54, 0x4d, 0xfe, 0x5f, 0x42, 0x37, +0x2d, 0x75, 0x65, 0x55, 0x0f, 0xc0, 0xfe, 0x2c, 0x22, 0x08, 0x6a, 0xf2, +0xff, 0x2f, 0x2a, 0x98, 0x28, 0x77, 0x05, 0xd8, 0xb1, 0xd0, 0x4f, 0xee, +0xdf, 0x72, 0xbf, 0x45, 0x0f, 0x4e, 0xc9, 0xa4, 0x79, 0x66, 0x76, 0x72, +0x85, 0xa6, 0xbd, 0xf6, 0x4d, 0xcf, 0xfd, 0xd9, 0x7f, 0x8f, 0x09, 0x61, +0x89, 0x27, 0x0e, 0x57, 0x16, 0x55, 0xbd, 0x5d, 0x6d, 0x6d, 0x17, 0xae, +0x27, 0x92, 0xf7, 0x2c, 0xae, 0xbd, 0x98, 0x4f, 0x56, 0x33, 0x26, 0x81, +0x90, 0x84, 0x2c, 0xd8, 0xa5, 0x4b, 0x1f, 0xad, 0xa0, 0xc8, 0xe4, 0x0c, +0x2e, 0x70, 0x99, 0x8d, 0x98, 0x30, 0x69, 0x3f, 0x8b, 0xfa, 0x6a, 0x47, +0xd5, 0x2b, 0xef, 0xd3, 0x96, 0x8d, 0x86, 0x21, 0x9b, 0xc1, 0x44, 0x82, +0x7c, 0x04, 0x74, 0xbd, 0x78, 0x58, 0x7b, 0xf7, 0x0e, 0xac, 0x67, 0xe0, +0x1a, 0x2b, 0x69, 0x0c, 0x6e, 0x00, 0x9b, 0x8d, 0x17, 0x72, 0x5f, 0xf9, +0x99, 0x7b, 0xf6, 0xf4, 0x96, 0xd4, 0xef, 0x6f, 0x4d, 0x28, 0x6a, 0xbb, +0x5b, 0xda, 0xa5, 0x6f, 0xf6, 0x87, 0x48, 0x40, 0x15, 0x3b, 0xf9, 0xf7, +0xc5, 0x7b, 0xcb, 0xcc, 0x8e, 0x7a, 0xd5, 0xf4, 0xef, 0x3d, 0x0b, 0x03, +0xf5, 0x3e, 0xa1, 0xc3, 0xf0, 0x96, 0x79, 0x3e, 0xad, 0x7b, 0x21, 0x59, +0x44, 0x61, 0x8f, 0x50, 0xc8, 0x7f, 0x8f, 0x32, 0xa6, 0xf0, 0x24, 0xa0, +0xd4, 0x2e, 0x50, 0x16, 0xac, 0xa5, 0xd5, 0xfe, 0xfa, 0xad, 0x0b, 0xc8, +0x33, 0x21, 0x7e, 0x22, 0xc8, 0xf7, 0x15, 0x8b, 0xed, 0xb5, 0x7c, 0xf2, +0xf8, 0x6a, 0x69, 0x89, 0x61, 0xcf, 0x1c, 0x0c, 0xe8, 0x49, 0xd0, 0x86, +0x03, 0x92, 0xf1, 0x10, 0x03, 0xbb, 0xbb, 0x67, 0xc1, 0xee, 0xd3, 0x6b, +0x59, 0xcb, 0xa5, 0xac, 0xd9, 0xde, 0xc4, 0xbf, 0xab, 0xf8, 0xdc, 0xc1, +0x8b, 0xf6, 0xd9, 0x3d, 0x8a, 0x04, 0x39, 0x30, 0x88, 0x17, 0x0e, 0xc0, +0x3b, 0xc0, 0x7a, 0x5d, 0x2c, 0xb5, 0x7c, 0x74, 0x30, 0x81, 0x00, 0xb8, +0x14, 0x1a, 0xe8, 0xaa, 0x43, 0x26, 0x86, 0x3d, 0xf3, 0x24, 0x46, 0xaa, +0x6c, 0xa2, 0x91, 0x1f, 0x9c, 0x15, 0x85, 0xb9, 0xc7, 0x0e, 0x99, 0x18, +0xb6, 0x47, 0x24, 0x46, 0x49, 0x58, 0x13, 0x62, 0x82, 0x43, 0x21, 0x24, +0x44, 0x01, 0xc3, 0xfe, 0x9e, 0xc6, 0x46, 0x20, 0x00, 0x7c, 0x13, 0x34, +0x84, 0x01, 0xc3, 0xc6, 0x32, 0x5a, 0x81, 0xc3, 0xcb, 0x84, 0x33, 0x13, +0x05, 0xc3, 0x86, 0xb5, 0x89, 0xa5, 0x10, 0x3e, 0x79, 0x0b, 0xa5, 0xdc, +0x59, 0xbc, 0x14, 0x0c, 0x23, 0x41, 0x0d, 0xf5, 0x79, 0x0b, 0x45, 0x0f, +0x26, 0x49, 0x6d, 0xf9, 0x68, 0xcd, 0xd1, 0x30, 0xac, 0xf2, 0xdc, 0x03, +0x27, 0xa9, 0xf1, 0x16, 0xca, 0xf7, 0xd1, 0xd7, 0x56, 0xc5, 0x78, 0x0f, +0x18, 0x56, 0x8d, 0x71, 0x3f, 0x04, 0xc2, 0x50, 0xbe, 0x12, 0x24, 0xbc, +0x68, 0x1d, 0xc3, 0x30, 0x42, 0x4b, 0x90, 0x9f, 0x9b, 0xab, 0xac, 0xbf, +0x8d, 0x78, 0x0d, 0x23, 0xb5, 0x2d, 0xc0, 0xb0, 0x46, 0x42, 0x4b, 0x94, +0xb5, 0x8e, 0x26, 0x0c, 0x35, 0x85, 0x6f, 0x08, 0x29, 0x61, 0x18, 0x55, +0x4b, 0x50, 0x56, 0x14, 0xaa, 0x3b, 0xbb, 0xa0, 0x27, 0x50, 0x11, 0x07, +0x0c, 0x23, 0xb4, 0x04, 0x05, 0x3c, 0x85, 0x5a, 0x0f, 0xb4, 0x69, 0xcb, +0x64, 0x42, 0x4a, 0x18, 0x86, 0x38, 0x00, 0xa2, 0xf0, 0x1e, 0xd3, 0xd4, +0x4b, 0x57, 0x10, 0x07, 0x0c, 0xab, 0xb6, 0x62, 0x89, 0xbc, 0x43, 0x47, +0x34, 0xd3, 0xfa, 0x42, 0x7b, 0xe8, 0x73, 0xbe, 0x01, 0xc3, 0xaa, 0x6c, +0xa3, 0x41, 0xce, 0xa1, 0x27, 0x4f, 0xa1, 0xf6, 0xd6, 0x17, 0xf2, 0xf9, +0xc4, 0xec, 0x75, 0x8d, 0x88, 0x03, 0x86, 0xd5, 0xe3, 0xd1, 0x9b, 0x2b, +0x69, 0xf1, 0x1a, 0xf0, 0x14, 0xb2, 0x94, 0xc5, 0x2d, 0xee, 0xef, 0xdd, +0xc7, 0x77, 0xed, 0x99, 0x2f, 0xde, 0x03, 0xe2, 0x80, 0x61, 0xa7, 0x73, +0x02, 0x1f, 0xee, 0x5c, 0x57, 0xd3, 0x4d, 0x98, 0xde, 0xde, 0x67, 0xff, +0x5b, 0xff, 0x7f, 0xe5, 0xea, 0x58, 0x9d, 0x9f, 0x88, 0x02, 0x39, 0x85, +0xac, 0xee, 0xa9, 0x1d, 0x70, 0x93, 0x26, 0xa3, 0x45, 0x1c, 0xa8, 0x54, +0xc2, 0x30, 0xc2, 0x3e, 0x30, 0x88, 0x28, 0x98, 0x01, 0xbc, 0x76, 0x91, +0xf9, 0x5d, 0xc5, 0x81, 0x32, 0x56, 0x6c, 0xe4, 0x10, 0xce, 0xc5, 0x7f, +0xcb, 0x0e, 0x1f, 0x41, 0x78, 0xec, 0x10, 0x9a, 0xba, 0xbb, 0xf9, 0x89, +0x30, 0x38, 0x1b, 0x56, 0x12, 0x71, 0x60, 0xa1, 0xc0, 0x46, 0xb5, 0x8b, +0x17, 0x09, 0xd1, 0xff, 0x08, 0x2f, 0xa1, 0xad, 0x9d, 0xb5, 0xc9, 0x31, +0x6c, 0xed, 0x6c, 0x6e, 0x88, 0x03, 0x86, 0xfd, 0x3d, 0xef, 0x73, 0x46, +0x20, 0xf0, 0x1e, 0x06, 0x14, 0x04, 0x59, 0x58, 0x5b, 0xbe, 0x89, 0xcd, +0x27, 0xba, 0x9e, 0x0d, 0xda, 0x9b, 0xfc, 0x1d, 0xc9, 0x37, 0x88, 0xb1, +0x40, 0x60, 0x08, 0xc4, 0x8f, 0x7f, 0x4e, 0x9e, 0xf7, 0xc1, 0x7b, 0x18, +0x20, 0x6c, 0x34, 0xb7, 0x7e, 0x35, 0xa7, 0x29, 0x83, 0x7b, 0x95, 0x28, +0x7b, 0x88, 0x83, 0x78, 0x0d, 0x54, 0x2b, 0x61, 0xd8, 0xc7, 0x26, 0x94, +0x27, 0xfe, 0x2d, 0x77, 0x2f, 0x74, 0xc4, 0xbd, 0x17, 0x41, 0x58, 0x11, +0x86, 0x3d, 0x03, 0x15, 0xcf, 0x01, 0xc3, 0x9e, 0xb4, 0x94, 0x39, 0xe1, +0xa9, 0x43, 0xa3, 0x22, 0x30, 0x59, 0x31, 0xe8, 0xed, 0x8e, 0x66, 0xff, +0xf3, 0x1c, 0x3d, 0x6a, 0xbf, 0x70, 0x08, 0x0e, 0xc3, 0xb6, 0x05, 0xe2, +0xe0, 0xa6, 0x11, 0xef, 0xa1, 0xc2, 0x90, 0xd0, 0xbb, 0x17, 0xe0, 0x82, +0x03, 0x29, 0x23, 0x94, 0x68, 0xbe, 0xa8, 0x4a, 0x7a, 0xc6, 0x2c, 0xed, +0xba, 0xe9, 0xad, 0x84, 0x61, 0xdb, 0x02, 0xb1, 0x77, 0xe3, 0xe4, 0xd7, +0x1a, 0x28, 0xb0, 0xf8, 0xab, 0x00, 0x2c, 0xba, 0xf3, 0x97, 0x97, 0xa1, +0x36, 0xea, 0x00, 0xbe, 0x20, 0x0c, 0x0f, 0xcf, 0x81, 0xae, 0xac, 0x18, +0x16, 0x4f, 0x20, 0xfc, 0x7c, 0x84, 0xc4, 0xbc, 0xb7, 0xa4, 0xe0, 0x80, +0xd6, 0xa5, 0xc4, 0xf3, 0x53, 0x71, 0x10, 0xcf, 0x81, 0x84, 0x34, 0x86, +0xc5, 0x13, 0x88, 0x0b, 0x9b, 0x35, 0xd8, 0x9b, 0x2c, 0x65, 0x60, 0xbe, +0x3c, 0xc3, 0x70, 0x35, 0xc6, 0x39, 0xeb, 0xdd, 0xd1, 0x08, 0x30, 0x86, +0xbd, 0x16, 0x88, 0x3d, 0x1e, 0x36, 0xde, 0x43, 0x62, 0x10, 0x87, 0x2c, +0xdd, 0x1a, 0x17, 0x15, 0x07, 0x9e, 0x2f, 0x86, 0xed, 0x13, 0x88, 0x9d, +0xf3, 0x85, 0xb3, 0x0f, 0x29, 0xc3, 0x4a, 0x0c, 0xc8, 0x4f, 0x95, 0x48, +0xf7, 0xd8, 0x02, 0x2c, 0xd5, 0x4a, 0xe4, 0x1b, 0x30, 0x2c, 0xae, 0x40, +0x70, 0x72, 0x1a, 0x81, 0xc8, 0x95, 0x6c, 0x4e, 0x52, 0x22, 0x87, 0x38, +0x60, 0x58, 0xd2, 0x10, 0x13, 0xb9, 0x07, 0x04, 0x22, 0x59, 0x8f, 0xf8, +0x29, 0xe1, 0x73, 0xbd, 0xab, 0x38, 0x10, 0x56, 0xc2, 0xb0, 0xf8, 0x49, +0x6a, 0x0e, 0xc6, 0x21, 0x10, 0xb1, 0x73, 0x09, 0x93, 0xcb, 0x73, 0x98, +0xe6, 0xd1, 0x95, 0x55, 0x2a, 0x95, 0x68, 0xbc, 0x87, 0x61, 0xc7, 0xed, +0xd5, 0x01, 0x52, 0xef, 0xf9, 0x13, 0x5a, 0xca, 0xb1, 0x98, 0xf5, 0x52, +0x51, 0x23, 0x3f, 0x87, 0xc9, 0x23, 0x2c, 0xae, 0xd0, 0x85, 0x21, 0xda, +0x3e, 0x83, 0x13, 0xd2, 0x18, 0x76, 0xce, 0x76, 0xcc, 0x9f, 0x89, 0xa5, +0x3b, 0x1f, 0x4b, 0xe3, 0xde, 0xc1, 0x92, 0xd1, 0x3b, 0x78, 0xc5, 0xcc, +0x21, 0x38, 0xac, 0xa5, 0x39, 0x54, 0xe3, 0x67, 0x7a, 0x21, 0x10, 0x54, +0x2d, 0xe1, 0x45, 0x3c, 0xad, 0x32, 0x9a, 0x5d, 0x9d, 0x7d, 0x57, 0xde, +0x2f, 0xfc, 0x21, 0xef, 0x80, 0xb5, 0x12, 0xeb, 0xaf, 0x6d, 0x23, 0x23, +0x6b, 0xd1, 0xd6, 0x75, 0xbb, 0x84, 0x96, 0xc8, 0x45, 0x6c, 0xe5, 0x0f, +0xaa, 0x6f, 0xc4, 0xa5, 0xa1, 0x25, 0xf2, 0x0e, 0x58, 0x4b, 0x1e, 0x44, +0x6d, 0xe3, 0x55, 0x05, 0x62, 0xe3, 0x73, 0x51, 0xb5, 0x54, 0x52, 0x24, +0x4a, 0x76, 0x59, 0x95, 0xef, 0x2d, 0x16, 0xf9, 0x80, 0x5a, 0xb6, 0x67, +0x77, 0xa6, 0x45, 0xf1, 0x08, 0x0b, 0x10, 0x79, 0x98, 0xba, 0x4d, 0xbc, +0xdd, 0x9a, 0xbc, 0x88, 0xad, 0x9b, 0x15, 0xa9, 0x5a, 0xaa, 0x83, 0x2c, +0x6d, 0x37, 0x34, 0xa1, 0xdc, 0x92, 0x87, 0xf0, 0xec, 0x99, 0xc9, 0xcf, +0x42, 0xde, 0xe1, 0xe3, 0x24, 0xaf, 0x6d, 0xe1, 0xc1, 0xb6, 0xdf, 0x55, +0x4d, 0x5e, 0x84, 0x6e, 0xb4, 0x56, 0x3e, 0x13, 0x89, 0xe9, 0x9a, 0x76, +0xc4, 0x57, 0x5a, 0x76, 0xab, 0x00, 0x58, 0xaf, 0x20, 0x48, 0x28, 0xf7, +0x14, 0x47, 0x5c, 0xf4, 0x46, 0x38, 0x16, 0x9c, 0x7f, 0x27, 0xb8, 0x3c, +0x0b, 0xc4, 0xa1, 0xad, 0xb2, 0xd2, 0x5a, 0x3c, 0x3d, 0x6d, 0x83, 0x6f, +0x05, 0x02, 0xef, 0xa1, 0xe2, 0x04, 0xb6, 0x33, 0xf7, 0x42, 0x87, 0x66, +0x92, 0xc6, 0xd6, 0xee, 0x03, 0x25, 0x92, 0xe6, 0x13, 0x9d, 0x27, 0xe9, +0xc2, 0x89, 0x55, 0x17, 0x66, 0xaa, 0xa5, 0xb0, 0x22, 0xbc, 0x27, 0x85, +0x76, 0x1a, 0xd0, 0x6c, 0x68, 0x89, 0xaa, 0xa5, 0xcf, 0xb1, 0x63, 0x9e, +0x45, 0x9b, 0xef, 0xae, 0x16, 0x0f, 0x78, 0xa5, 0xc4, 0x95, 0xd0, 0x12, +0xb4, 0xe9, 0x3d, 0xe8, 0xdd, 0x0e, 0xb4, 0xef, 0xfe, 0x77, 0x62, 0x53, +0xc1, 0xd5, 0x6e, 0x31, 0x41, 0x0d, 0x39, 0x34, 0xfd, 0x1c, 0x66, 0x93, +0x81, 0x38, 0x40, 0xdb, 0xde, 0x03, 0xb1, 0xf6, 0x7f, 0xc3, 0x02, 0x88, +0x43, 0xfb, 0x79, 0x88, 0xd2, 0xef, 0xd0, 0x7a, 0x32, 0xdc, 0xf3, 0x00, +0xcd, 0xa2, 0x8d, 0xf8, 0x58, 0x14, 0xeb, 0x0a, 0x4f, 0x60, 0xd7, 0x8b, +0x0b, 0x4a, 0x7f, 0x06, 0x33, 0xa7, 0xee, 0xac, 0x34, 0xd0, 0x64, 0x68, +0x89, 0x76, 0x1a, 0x9b, 0x21, 0x01, 0xac, 0xf1, 0x1c, 0x52, 0xc9, 0x02, +0x03, 0xf5, 0x44, 0x7d, 0xc8, 0x16, 0xa0, 0xbd, 0xd0, 0x92, 0x9e, 0x79, +0xc0, 0x7b, 0xa8, 0x23, 0x2c, 0x81, 0xc5, 0xcd, 0x23, 0x95, 0x12, 0xfb, +0x20, 0x0f, 0xc2, 0x89, 0x69, 0x68, 0x37, 0xb4, 0x44, 0x62, 0x1a, 0x71, +0xe8, 0xf5, 0x9d, 0x96, 0x0a, 0x33, 0xa9, 0x07, 0xe3, 0xe7, 0x15, 0xe1, +0x25, 0x68, 0x53, 0x1c, 0x08, 0x2d, 0x95, 0x5d, 0x48, 0xb0, 0xf4, 0xe7, +0x58, 0x4a, 0x6c, 0x7e, 0x82, 0x8a, 0x40, 0xce, 0x3d, 0x40, 0x53, 0x2c, +0x6b, 0x27, 0x3c, 0x47, 0xb4, 0xf0, 0x20, 0x13, 0x46, 0x1e, 0x22, 0x56, +0x78, 0xcb, 0x8f, 0x29, 0xda, 0x79, 0x43, 0x53, 0xbc, 0x37, 0xe2, 0x1b, +0x7d, 0x61, 0xd4, 0x5d, 0x1e, 0xe2, 0xd0, 0x77, 0x1e, 0x22, 0xf7, 0xfb, +0xd5, 0x4a, 0x38, 0xbc, 0x07, 0x68, 0x0e, 0x49, 0x4a, 0xeb, 0xe9, 0xce, +0x51, 0xc3, 0x2a, 0xda, 0x16, 0x9a, 0x36, 0x1a, 0x9c, 0x69, 0x49, 0x15, +0xda, 0xf2, 0xc9, 0x71, 0xbc, 0x07, 0x68, 0x33, 0xb4, 0x34, 0xa2, 0xf7, +0x20, 0xc2, 0xa0, 0x5e, 0x83, 0x18, 0xe2, 0xc0, 0xb9, 0x96, 0x54, 0x9b, +0x0f, 0x3f, 0xb6, 0x48, 0x4e, 0x43, 0x3b, 0xa1, 0x25, 0x8d, 0xc9, 0x8e, +0xe8, 0x3d, 0xe8, 0x42, 0xa1, 0x79, 0x17, 0xc4, 0x61, 0x9c, 0x4d, 0x41, +0xce, 0x2a, 0x3d, 0x1d, 0x67, 0x9c, 0x9c, 0x86, 0x96, 0xb8, 0xd9, 0xd0, +0xd2, 0x48, 0xa1, 0x15, 0xbd, 0xcb, 0x01, 0x61, 0x18, 0x3b, 0x0f, 0x91, +0xeb, 0xbd, 0xab, 0x87, 0x8a, 0x40, 0x40, 0x53, 0xe2, 0xa0, 0x31, 0xf7, +0x51, 0x16, 0x49, 0x0d, 0x27, 0xa9, 0xb7, 0x84, 0x30, 0x8c, 0x5d, 0xc6, +0x9c, 0x2b, 0x9c, 0x6a, 0xbb, 0xb7, 0xfa, 0x2b, 0x04, 0x08, 0x33, 0x41, +0xbd, 0x8c, 0x76, 0xde, 0x41, 0x84, 0x41, 0xfb, 0xf0, 0x50, 0xc6, 0x8b, +0xb9, 0x8f, 0x49, 0xe3, 0x6c, 0x3d, 0xa0, 0xb4, 0x65, 0x8b, 0x0f, 0x6d, +0x71, 0x92, 0x1a, 0xaa, 0x64, 0x51, 0x97, 0xb7, 0xf7, 0x1d, 0xb4, 0x0d, +0x25, 0xa9, 0x30, 0xd0, 0xb6, 0x1c, 0x73, 0x85, 0xae, 0x21, 0x55, 0xa1, +0x30, 0x73, 0x8f, 0x8a, 0x26, 0xa8, 0x27, 0xac, 0x24, 0x9e, 0x83, 0x0c, +0xcc, 0xde, 0xbd, 0x06, 0x9d, 0xfc, 0x56, 0x18, 0x08, 0x27, 0x61, 0x25, +0xf3, 0x10, 0x6e, 0xe3, 0xca, 0x5a, 0x9f, 0x97, 0x20, 0xe4, 0x04, 0x45, +0x99, 0x7b, 0xdf, 0x39, 0xab, 0xf0, 0xd9, 0xa4, 0x3b, 0xc2, 0x80, 0xbd, +0x12, 0x88, 0x92, 0x3d, 0xc7, 0x64, 0xbc, 0x8a, 0x11, 0x72, 0x82, 0x52, +0xdc, 0xfd, 0x0e, 0x65, 0x18, 0x6f, 0x01, 0x61, 0xc0, 0x8e, 0x08, 0x44, +0xe9, 0x82, 0x05, 0xcd, 0x8f, 0x91, 0xc0, 0x06, 0xbc, 0x86, 0x44, 0x89, +0x3f, 0x9d, 0xe4, 0x3a, 0xd1, 0x58, 0xfc, 0xb0, 0xbd, 0x63, 0x28, 0xdc, +0x58, 0x98, 0x1d, 0x7d, 0x76, 0xa1, 0x30, 0xbf, 0x4a, 0x6e, 0x82, 0x76, +0x1c, 0x90, 0x26, 0xd7, 0xe0, 0x07, 0x58, 0xb7, 0x49, 0x67, 0x2b, 0x0c, +0xf2, 0xff, 0xa5, 0x26, 0x35, 0xf6, 0x7a, 0xd1, 0x13, 0x0f, 0x56, 0x4c, +0x76, 0xc7, 0x62, 0xb5, 0x79, 0xb4, 0x61, 0x21, 0x83, 0x6e, 0x36, 0xe4, +0xf7, 0x4a, 0x6e, 0x36, 0x08, 0x3b, 0x01, 0x21, 0xa5, 0x03, 0x13, 0xd8, +0x86, 0x91, 0x6a, 0x98, 0xc0, 0x76, 0x22, 0xf7, 0x2c, 0x4e, 0xba, 0xc8, +0xeb, 0x02, 0x1f, 0x9a, 0xdf, 0x8c, 0xcc, 0xc6, 0x26, 0x6f, 0xf7, 0x8d, +0x5d, 0xf0, 0x5c, 0xd1, 0xcf, 0xf7, 0xf8, 0xec, 0xf2, 0xf3, 0x69, 0xa8, +0x27, 0x14, 0x0b, 0x53, 0x96, 0x5a, 0xe4, 0x33, 0xfa, 0x67, 0x3c, 0xb1, +0xb4, 0xc1, 0x25, 0xaf, 0x41, 0x06, 0x52, 0x2f, 0x0b, 0xd5, 0x9a, 0xa7, +0x60, 0x7b, 0x45, 0xd5, 0xf2, 0x73, 0x9a, 0x8b, 0x5f, 0x6e, 0xfe, 0x57, +0x5d, 0x1c, 0x65, 0x11, 0x5c, 0x74, 0xc7, 0xbc, 0x65, 0xa5, 0x7e, 0x8e, +0x70, 0xd1, 0x7f, 0xb2, 0xc0, 0xa7, 0x88, 0x87, 0xdf, 0x2b, 0x79, 0x6f, +0xd3, 0xca, 0xe7, 0x7a, 0x88, 0x45, 0x8d, 0x05, 0x0f, 0xfe, 0x3d, 0x11, +0x76, 0x82, 0xc3, 0x4c, 0x3d, 0x78, 0x0d, 0xba, 0x7b, 0x5b, 0x13, 0x85, +0x8a, 0x13, 0xcf, 0x57, 0x77, 0x76, 0x37, 0xb3, 0x10, 0x2f, 0x56, 0x34, +0x74, 0x77, 0x6e, 0x43, 0x33, 0xd6, 0xcc, 0xee, 0x7d, 0xcb, 0xec, 0xa2, +0x7f, 0x0f, 0xac, 0xe4, 0x42, 0x73, 0xaf, 0x50, 0x1c, 0x3e, 0xcd, 0x29, +0x79, 0x86, 0xe1, 0x01, 0x4b, 0x9b, 0xa7, 0x20, 0xec, 0x04, 0x4d, 0x88, +0x43, 0xcb, 0x5e, 0x82, 0x4c, 0x34, 0xbd, 0xb9, 0x6d, 0x4b, 0x14, 0x2a, +0xce, 0x2f, 0xa4, 0x3a, 0xe4, 0x64, 0x45, 0x63, 0x5a, 0xb1, 0x5b, 0xe3, +0x3b, 0xc9, 0xa5, 0x72, 0x71, 0x08, 0xc5, 0xec, 0x21, 0x14, 0xa1, 0x57, +0x5b, 0x52, 0x28, 0xa8, 0x76, 0x82, 0x3d, 0xcc, 0x2d, 0x0a, 0x42, 0x98, +0x4f, 0x08, 0x93, 0x83, 0x3a, 0xf1, 0x6a, 0xae, 0x46, 0xf2, 0x13, 0x14, +0x4e, 0x50, 0xca, 0xdb, 0xf5, 0xe3, 0xe9, 0xec, 0xee, 0xfb, 0x66, 0xbd, +0x8a, 0xf0, 0x74, 0x7e, 0xc1, 0xb1, 0xca, 0x49, 0x6c, 0xa8, 0x6b, 0x17, +0x76, 0xd6, 0x4b, 0x78, 0x26, 0x08, 0x2d, 0x55, 0x22, 0x21, 0x0e, 0xed, +0x85, 0x97, 0x4c, 0x38, 0x2e, 0xca, 0xcf, 0xa0, 0xf9, 0x3e, 0xeb, 0x51, +0xe4, 0xea, 0xeb, 0x84, 0x37, 0x01, 0xcd, 0x8a, 0x83, 0xf5, 0x12, 0x9e, +0x85, 0x8d, 0x6a, 0xa9, 0x40, 0x42, 0x1c, 0x86, 0x08, 0x89, 0xa6, 0xda, +0x65, 0xbf, 0x0b, 0x85, 0xed, 0xb1, 0x54, 0xa2, 0xea, 0x89, 0xdc, 0x04, +0x54, 0x1b, 0x56, 0xd2, 0x09, 0xb2, 0xe5, 0x25, 0x68, 0x8e, 0xa1, 0x55, +0x51, 0x40, 0x1c, 0x9a, 0x1e, 0xbf, 0x39, 0x42, 0x30, 0x37, 0x67, 0x12, +0xda, 0x85, 0xc7, 0x3b, 0x07, 0xec, 0x46, 0x76, 0xcf, 0x6b, 0x0a, 0xc1, +0x3c, 0x2b, 0x45, 0xb5, 0xb9, 0x84, 0x92, 0xe5, 0x9c, 0xb1, 0x8c, 0x8b, +0x5e, 0x9a, 0xf4, 0x7e, 0x73, 0xc7, 0xe7, 0x1f, 0x42, 0xa1, 0x65, 0xb2, +0x9a, 0x6b, 0xcb, 0x2d, 0x14, 0x7e, 0xac, 0x4e, 0x0c, 0xb5, 0xb1, 0xb8, +0xd5, 0x54, 0xca, 0x1a, 0xb6, 0x28, 0x08, 0xab, 0x8e, 0xfc, 0x67, 0x5d, +0xcc, 0x40, 0xbd, 0xb7, 0x78, 0x4e, 0xc3, 0xb4, 0x3d, 0x80, 0x08, 0x78, +0x2f, 0x6c, 0x04, 0x6f, 0xef, 0x1e, 0x7a, 0x15, 0x05, 0x3c, 0x0a, 0x44, +0x82, 0x89, 0x55, 0xee, 0x0e, 0xe7, 0xb0, 0x07, 0xd2, 0x8a, 0x28, 0x6c, +0xed, 0xb2, 0xaa, 0xef, 0x11, 0xe5, 0x7f, 0x96, 0x19, 0x77, 0x3d, 0xee, +0x26, 0x27, 0xc7, 0x7b, 0xaf, 0x2c, 0x14, 0xf8, 0x18, 0xef, 0x32, 0x9e, +0x54, 0x28, 0x32, 0x8b, 0x04, 0x79, 0x09, 0xdc, 0xf2, 0x32, 0x1d, 0x53, +0x75, 0x47, 0x74, 0xb2, 0x8a, 0xa2, 0x2a, 0x8f, 0x22, 0x38, 0x78, 0xc6, +0xce, 0x2b, 0xdd, 0xae, 0x3a, 0x87, 0xb0, 0xd7, 0x2a, 0xea, 0xb3, 0x7a, +0x14, 0x39, 0x2b, 0xf6, 0x38, 0x81, 0xdd, 0x37, 0x45, 0x93, 0xd2, 0x61, +0xcd, 0xb7, 0x26, 0xdf, 0x8c, 0xb7, 0x70, 0x75, 0xe0, 0xdd, 0x4b, 0x7b, +0x47, 0x54, 0x80, 0x74, 0x35, 0x96, 0x6b, 0x17, 0xf7, 0x77, 0x8f, 0x22, +0xe7, 0xe6, 0xe8, 0xc4, 0x01, 0x41, 0x68, 0x81, 0x92, 0x79, 0x07, 0xdb, +0x62, 0x20, 0x08, 0x23, 0xa5, 0x08, 0xbd, 0x14, 0x0f, 0x3b, 0x91, 0xdc, +0x6b, 0xde, 0x13, 0x6e, 0x4d, 0xe4, 0xef, 0x2a, 0x14, 0xb9, 0xc2, 0x4e, +0x9c, 0x99, 0x60, 0x42, 0x45, 0x0f, 0x27, 0x89, 0xc7, 0x90, 0xa9, 0xa3, +0x64, 0x2d, 0x6d, 0xca, 0x29, 0x15, 0x4c, 0x40, 0x62, 0x4f, 0xb1, 0x65, +0x0f, 0x70, 0xce, 0xb9, 0x11, 0xc4, 0x9b, 0xe8, 0x83, 0xa9, 0xc4, 0x8e, +0x7a, 0xa3, 0x85, 0x40, 0xee, 0xc9, 0x37, 0x95, 0x0e, 0x3b, 0x71, 0x4f, +0x70, 0x53, 0xde, 0x70, 0x0f, 0xe1, 0xc1, 0x9b, 0x8e, 0xfb, 0x8c, 0xf3, +0x1e, 0x91, 0x68, 0x94, 0xec, 0xe7, 0x1d, 0x6c, 0x75, 0x92, 0xb9, 0x7e, +0xb1, 0xf4, 0x4e, 0x7a, 0x29, 0x19, 0x76, 0xaa, 0x3c, 0xe1, 0xd9, 0xdc, +0x98, 0x76, 0xfd, 0x57, 0x2c, 0xc5, 0x7c, 0x56, 0xb9, 0x3c, 0x69, 0x36, +0x41, 0xec, 0xb4, 0xf6, 0x7b, 0x0d, 0x26, 0x9c, 0x54, 0xcb, 0xc0, 0x29, +0x9a, 0xc4, 0xe6, 0xf4, 0x74, 0xbc, 0x30, 0x4a, 0x22, 0x01, 0xef, 0x5a, +0x54, 0x53, 0x8f, 0x7d, 0x0e, 0x80, 0x32, 0x91, 0x76, 0x79, 0x0d, 0xa6, +0x75, 0x71, 0xad, 0xf1, 0xf7, 0x92, 0xb9, 0x09, 0x5c, 0xf1, 0x3a, 0xdf, +0xdf, 0x28, 0xbb, 0xdf, 0xd4, 0xf7, 0xbd, 0x70, 0x10, 0x74, 0xf0, 0x89, +0xb4, 0x79, 0x12, 0x5a, 0xab, 0x93, 0x1a, 0xb9, 0xd6, 0xb0, 0xc8, 0xc5, +0x48, 0x84, 0x9a, 0xaa, 0x1c, 0xd7, 0xa3, 0x95, 0x25, 0xa7, 0x2e, 0xe0, +0x20, 0xd4, 0x44, 0x78, 0xe9, 0xdf, 0x0a, 0x06, 0xdb, 0x4c, 0xac, 0xc1, +0xfb, 0x6e, 0x4b, 0x55, 0x3a, 0xb1, 0xcb, 0xba, 0x40, 0xe4, 0x50, 0xc9, +0xc8, 0xef, 0xe2, 0x71, 0x2d, 0x6a, 0xec, 0xd0, 0x13, 0xa1, 0x54, 0xc2, +0x4b, 0xef, 0x21, 0x25, 0x11, 0x08, 0x73, 0x9e, 0xa1, 0xd9, 0x67, 0x95, +0x33, 0x81, 0x4d, 0xac, 0xf6, 0x9a, 0xa8, 0xc7, 0x7a, 0x57, 0xbc, 0x87, +0x8f, 0x1e, 0x75, 0xe4, 0xaa, 0x27, 0xbc, 0x88, 0x11, 0x26, 0x91, 0xdb, +0x48, 0x44, 0x07, 0xe1, 0xa4, 0x2e, 0x76, 0x53, 0x99, 0x43, 0x4e, 0x9c, +0xb6, 0x3e, 0xbf, 0xeb, 0x25, 0x1f, 0x94, 0xd8, 0xab, 0x8e, 0xb0, 0x7e, +0xe0, 0x25, 0x57, 0x4c, 0xb2, 0xb0, 0x89, 0x8a, 0x83, 0x2f, 0x5d, 0xed, +0x6e, 0x82, 0xe5, 0xaa, 0x72, 0xf2, 0x13, 0x90, 0x5c, 0x44, 0x21, 0xcf, +0x98, 0x30, 0xc8, 0x6b, 0x21, 0xbe, 0x22, 0x12, 0xfe, 0xdf, 0xe2, 0x45, +0xd4, 0x48, 0x8a, 0x9d, 0xb0, 0x0d, 0x29, 0x0d, 0xd0, 0xb0, 0x2b, 0x4b, +0x5e, 0x82, 0x45, 0xaa, 0xcc, 0xbb, 0x21, 0xb4, 0x94, 0x47, 0x8c, 0x19, +0xdf, 0x83, 0x84, 0x97, 0x56, 0xc4, 0x81, 0x85, 0x08, 0x2f, 0xa2, 0xe5, +0xcd, 0x0f, 0xe1, 0x8f, 0x7c, 0xcf, 0x1b, 0x2f, 0xa2, 0xe7, 0x10, 0x89, +0x88, 0x83, 0x94, 0xb0, 0x9a, 0x73, 0x0d, 0x23, 0x91, 0xa3, 0x45, 0x09, +0x8b, 0xd5, 0x81, 0xb0, 0x47, 0x24, 0x51, 0x66, 0xd1, 0xca, 0xb7, 0x51, +0x22, 0xd7, 0xd6, 0xab, 0xf7, 0xa0, 0x9e, 0x83, 0xe4, 0x1d, 0x06, 0x7e, +0xd1, 0x49, 0x6f, 0xdf, 0xc3, 0x8b, 0xc8, 0x17, 0xf2, 0x20, 0xec, 0x91, +0xdf, 0x8b, 0xe0, 0x79, 0x77, 0x36, 0x81, 0x42, 0x71, 0x18, 0xd4, 0x73, +0xf8, 0x24, 0x12, 0x89, 0x93, 0xd7, 0x13, 0x43, 0x37, 0xcb, 0x6e, 0x96, +0x1d, 0xed, 0x49, 0xcf, 0xed, 0xec, 0xc6, 0x93, 0x7c, 0x4f, 0x27, 0x4a, +0xef, 0x56, 0xfa, 0x29, 0x15, 0xea, 0xbe, 0xda, 0xfb, 0x02, 0xc5, 0x2e, +0xeb, 0x24, 0x57, 0x45, 0x1a, 0x6f, 0x2d, 0xff, 0xd8, 0xe7, 0x99, 0x57, +0xa4, 0xf2, 0x2e, 0xd2, 0xc9, 0x68, 0x23, 0x0e, 0xec, 0x6c, 0x33, 0x88, +0x04, 0xbb, 0xac, 0x7d, 0x5e, 0xdc, 0xd5, 0xf0, 0x29, 0x42, 0x5c, 0xc6, +0x8b, 0x60, 0x93, 0x59, 0x07, 0x53, 0x8c, 0x90, 0x52, 0xcf, 0x67, 0x1c, +0x2a, 0xf7, 0x24, 0x48, 0x9c, 0x26, 0x1c, 0xdf, 0x8e, 0x50, 0x5e, 0x0c, +0xce, 0x86, 0xb0, 0x29, 0xc4, 0x68, 0x79, 0xd1, 0xd2, 0x4a, 0x25, 0x11, +0x07, 0xae, 0xca, 0x4c, 0x3e, 0x59, 0xd8, 0x65, 0x15, 0x78, 0xde, 0x78, +0x69, 0x71, 0x38, 0x19, 0xe6, 0x63, 0x6c, 0xb7, 0xea, 0x7e, 0xab, 0x38, +0x98, 0x9e, 0x4a, 0xec, 0x64, 0xf3, 0xee, 0x6a, 0xd9, 0x65, 0xa5, 0x5b, +0x98, 0x78, 0xbe, 0x75, 0x84, 0x9a, 0x78, 0xf6, 0xa5, 0x5f, 0xda, 0xd9, +0x89, 0x23, 0xc2, 0x30, 0xc8, 0xe9, 0xe8, 0xaa, 0x3d, 0x09, 0xe2, 0xe3, +0x69, 0x36, 0x40, 0x8e, 0xb3, 0x0f, 0x35, 0x88, 0x04, 0x02, 0xd1, 0xe2, +0x4e, 0x56, 0xbd, 0x07, 0xdc, 0xef, 0xcb, 0x5c, 0xce, 0x49, 0x50, 0xed, +0xf1, 0x5c, 0x20, 0xf0, 0x1e, 0x9a, 0xde, 0x18, 0x4d, 0x3c, 0xae, 0x06, +0x77, 0xb1, 0x72, 0xc6, 0x41, 0xf2, 0x0e, 0xec, 0x5e, 0xcb, 0x87, 0x40, +0xd8, 0xe5, 0xc6, 0xdf, 0x00, 0x39, 0x62, 0xe0, 0xb5, 0x6c, 0x8c, 0x18, +0xd7, 0x2d, 0xee, 0x60, 0x65, 0x51, 0x92, 0x33, 0x0f, 0xbe, 0x6a, 0x89, +0xdd, 0xeb, 0xc5, 0x5d, 0x2e, 0x7d, 0x6b, 0xea, 0xda, 0x00, 0xb1, 0x83, +0x2d, 0xbf, 0x31, 0x62, 0xf3, 0xd9, 0x41, 0x88, 0x43, 0x04, 0x82, 0x17, +0x19, 0x85, 0xfb, 0xc5, 0x5a, 0x7d, 0x04, 0x22, 0xf2, 0xf8, 0x26, 0x7c, +0x5a, 0x46, 0x24, 0xfc, 0x3c, 0x20, 0xb4, 0xd7, 0x83, 0x40, 0xb0, 0xd3, +0xaa, 0x66, 0xb7, 0x8b, 0x40, 0x44, 0x1e, 0xdf, 0x6c, 0x7c, 0xf2, 0xbd, +0x23, 0x11, 0x63, 0x2f, 0xc8, 0x0b, 0x63, 0xb9, 0x43, 0x81, 0xf0, 0xaa, +0x4f, 0xbc, 0x36, 0xb1, 0xdb, 0x8d, 0x40, 0x20, 0x10, 0x00, 0x2d, 0x7a, +0x10, 0x24, 0xf5, 0xe2, 0x70, 0x36, 0xd4, 0x84, 0x40, 0x44, 0x1e, 0xdf, +0xfe, 0x3d, 0xe0, 0x19, 0x03, 0x13, 0xc8, 0x71, 0x4f, 0x41, 0x4d, 0x1c, +0x0a, 0x35, 0x51, 0xe6, 0xfa, 0x94, 0xc9, 0xc5, 0x39, 0x67, 0x32, 0xf1, +0x8c, 0x81, 0x90, 0x06, 0x22, 0xd1, 0xa2, 0x48, 0xe0, 0xb5, 0x25, 0x14, +0x08, 0xf7, 0x31, 0x69, 0x8d, 0x47, 0x01, 0xe3, 0x70, 0xa5, 0xbc, 0x52, +0x76, 0xae, 0xfe, 0xce, 0x07, 0xdc, 0xf3, 0x42, 0x8b, 0x9b, 0x7f, 0xce, +0xb0, 0xcd, 0xe5, 0x4e, 0xc5, 0x6c, 0x7e, 0x00, 0x81, 0xb8, 0x50, 0xe6, +0x2a, 0xed, 0x36, 0x10, 0x88, 0x74, 0x0b, 0xdc, 0x0b, 0x2f, 0x0f, 0xef, +0x21, 0xf1, 0x18, 0x47, 0x24, 0x80, 0xc9, 0x73, 0xf1, 0x92, 0xa0, 0x35, +0x91, 0xa0, 0x0a, 0x24, 0xba, 0x37, 0x31, 0xcb, 0x33, 0x15, 0xf1, 0xf5, +0xef, 0x0d, 0x71, 0xd8, 0x47, 0x92, 0xcb, 0x9a, 0xd8, 0x00, 0x01, 0x02, +0xb1, 0x33, 0xd4, 0x24, 0x7d, 0x99, 0x36, 0xc2, 0x4d, 0x4c, 0xa2, 0xf8, +0x90, 0x2c, 0x3d, 0x46, 0xec, 0xf6, 0xea, 0x1c, 0xa4, 0x03, 0x04, 0xc2, +0x9d, 0xe8, 0xec, 0x8a, 0x17, 0x01, 0x35, 0x0a, 0xea, 0xd5, 0x1b, 0xe5, +0x1c, 0x21, 0x3e, 0x40, 0x20, 0xae, 0xdf, 0x45, 0xbd, 0x31, 0x11, 0xa9, +0xd1, 0x87, 0x2e, 0xc6, 0x39, 0x5e, 0x04, 0x0c, 0x45, 0xac, 0x32, 0xd7, +0xe0, 0x3e, 0x6a, 0x04, 0x02, 0x6a, 0x23, 0x55, 0x1e, 0x42, 0x8c, 0x90, +0x1f, 0xe0, 0x7e, 0xbb, 0x27, 0xad, 0xbf, 0x45, 0x1c, 0xd6, 0x04, 0x82, +0x1d, 0x16, 0x54, 0xc2, 0x9d, 0x30, 0x13, 0x40, 0xe6, 0xc9, 0x63, 0xc5, +0x41, 0xc2, 0x4c, 0x8e, 0x1c, 0x04, 0xd4, 0x4b, 0x92, 0x64, 0xb5, 0xa3, +0xe4, 0x15, 0x46, 0x10, 0x89, 0xa3, 0xe1, 0x26, 0xbd, 0x13, 0x42, 0xc2, +0x4b, 0x5b, 0x07, 0xe6, 0xd8, 0x5d, 0x41, 0x4d, 0x24, 0xea, 0x1c, 0x80, +0x40, 0xc0, 0x38, 0x42, 0xe1, 0x17, 0xf5, 0x45, 0x26, 0x93, 0x84, 0x88, +0xac, 0x77, 0xb1, 0x91, 0x63, 0xf8, 0x94, 0xb8, 0x33, 0xfd, 0x6b, 0x00, +0x6a, 0xe2, 0x96, 0x40, 0x24, 0xd8, 0x04, 0xc1, 0xd8, 0x93, 0xca, 0x2f, +0xf6, 0xef, 0xc2, 0x11, 0x9a, 0xdf, 0x45, 0xcd, 0x2e, 0x5e, 0x42, 0x9a, +0xc4, 0x1f, 0x24, 0x1b, 0xcf, 0xb1, 0xaa, 0x9a, 0xfc, 0xd7, 0x61, 0xac, +0x02, 0x14, 0x10, 0x25, 0x26, 0x1e, 0xa4, 0xf6, 0x96, 0x1f, 0x1e, 0xf3, +0xda, 0xa6, 0x67, 0x63, 0xf3, 0x73, 0x37, 0x9b, 0x25, 0x3c, 0x64, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x81, 0xff, 0x03, +0xea, 0x8b, 0x7d, 0x28, 0xd4, 0x03, 0x8b, 0x6b, 0x00, 0x00, 0x00, 0x00, +0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82}; +constexpr unsigned int __cat_png_len = 52976; +constexpr unsigned int __cat_png_x = 1024; +constexpr unsigned int __cat_png_y = 550; diff --git a/kernel/assets/cat.png b/kernel/assets/cat.png new file mode 100644 index 0000000000000000000000000000000000000000..acecd3c8d9f4c61fa3a2df4f528492adfd3a548f GIT binary patch literal 52976 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
)vtd)Tv`Wi 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 Vv7w>w763~e22WQ%mvv4FO#oe_L#Y4& literal 0 HcmV?d00001 diff --git a/kernel/boot/longmode.asm b/kernel/boot/longmode.asm new file mode 100644 index 0000000..2b9d1b8 --- /dev/null +++ b/kernel/boot/longmode.asm @@ -0,0 +1,250 @@ +; The stony path to Long Mode (64-bit)... +; ... begins in 32-bit Protected Mode +[BITS 32] + +; Pointer to Long Mode Global Descriptor Table (GDT, arch/gdt.cc) +[EXTERN gdt_long_mode_pointer] + +[GLOBAL long_mode] +long_mode: + +; You can check if the CPU supports Long Mode by using the `cpuid` command. +; Problem: You first have to figure out if the `cpuid` command itself is +; supported. Therefore, you have to try to reverse the 21st bit in the EFLAGS +; register -- if it works, then there is the 'cpuid' instruction. +CPUID_BIT_MASK equ 1 << 21 + +check_cpuid: + ; Save EFLAGS on stack + pushfd + + ; Copy stored EFLAGS from stack to EAX register + mov eax, [esp] + + ; Flip the 21st bit (ID) in EAX + xor eax, CPUID_BIT_MASK + + ; Copy EAX to EFLAGS (using the stack) + push eax + popfd + + ; And reverse: copy EFLAGS to EAX (using the stack) + ; (but the 21st bit should now still be flipped, if `cpuid` is supported) + pushfd + pop eax + + ; Compare the new EFLAGS copy (residing in EAX) with the EFLAGS stored at + ; the beginning of this function by using an exclusive OR -- all different + ; (flipped) bits will be stored in EAX. + xor eax, [esp] + + ; Restore original EFLAGS + popfd + + ; If 21st Bit in EAX is set, `cpuid` is supported -- continue at check_long_mode + and eax, CPUID_BIT_MASK + jnz check_long_mode + + ; Show error message "No CPUID" and stop CPU + mov dword [0xb8000], 0xcf6fcf4e + mov dword [0xb8004], 0xcf43cf20 + mov dword [0xb8008], 0xcf55cf50 + mov dword [0xb800c], 0xcf44cf49 + hlt + + +; Now you are able to use the `cpuid` instruction to check if Long Mode is +; available -- after you've checked if the `cpuid` is able to perform the +; check itself (since it is an extended `cpuid` function)... + +CPUID_GET_LARGEST_EXTENDED_FUNCTION_NUMBER equ 0x80000000 +CPUID_GET_EXTENDED_PROCESSOR_FEATURES equ 0x80000001 +CPUID_HAS_LONGMODE equ 1 << 29 + +check_long_mode: + ; Set argument for `cpuid` to check the availability of extended functions + ; and call cpuid + mov eax, CPUID_GET_LARGEST_EXTENDED_FUNCTION_NUMBER + cpuid + ; The return value contains the maximum function number supported by `cpuid`, + ; You'll need the function number for extended processor features + cmp eax, CPUID_GET_EXTENDED_PROCESSOR_FEATURES + ; If not present, the CPU is definitely too old to support long mode + jb no_long_mode + + ; Finally, you are able to check the Long Mode support itself + mov eax, CPUID_GET_EXTENDED_PROCESSOR_FEATURES + cpuid + ; If the return value in the EDX register has set the 29th bit, + ; then long mode is supported -- continue with setup_paging + test edx, CPUID_HAS_LONGMODE + jnz setup_paging + +no_long_mode: + ; Show error message "No 64bit" and stop CPU + mov dword [0xb8000], 0xcf6fcf4e + mov dword [0xb8004], 0xcf36cf20 + mov dword [0xb8008], 0xcf62cf34 + mov dword [0xb800c], 0xcf74cf69 + hlt + + +; Paging is required for Long Mode. +; Since an extensive page manager might be a bit of an overkill to start with, +; the following code creates an identity mapping for the first four gigabytes +; (using huge pages): each virtual address will point to the same physical one. +; This area (up to 4 GiB) is important for some memory mapped devices (APIC) +; and you don't want to remap them yet for simplicity reasons. +; In the advanced operating systems lecture, this topic is covered in detail, +; however, if you want a quick overview, have a look at +; https://wiki.osdev.org/Page_Tables#2_MiB_pages_2 + +PAGE_SIZE equ 4096 +PAGE_FLAGS_PRESENT equ 1 << 0 +PAGE_FLAGS_WRITEABLE equ 1 << 1 +PAGE_FLAGS_USER equ 1 << 2 +PAGE_FLAGS_HUGE equ 1 << 7 + +setup_paging: + ; Unlike in Protected Mode, an entry in the page table has a size of 8 bytes + ; (vs 4 bytes), so there are only 512 (and not 1024) entries per table. + ; Structure of the 3-level PAE paging: One entry in the + ; - lv2: Page-Directory-Table (PDT) covers 2 MiB (1 Huge Page) + ; - lv3: Page-Directory-Pointer-Table (PDPT) covers 1 GiB (512 * 2 MiB) + ; - lv4: Page-Map-Level-4-Table (PML4) covers 512 GiB (512 * 1 GiB) + + ; To address 4 GiB only four level-2 tables are required. + ; All entries of the level-2 tables should be marked as writeable (attributes) + ; and map (point to) the corresponding physical memory. + + ; This is done in a loop using ECX as counter + mov ecx, 0 + +.identitymap_level2: + ; Calculate physical address in EAX (2 MiB multiplied by the counter) + mov eax, 0x200000 + mul ecx + ; Configure page attributes + or eax, PAGE_FLAGS_PRESENT | PAGE_FLAGS_WRITEABLE | PAGE_FLAGS_HUGE | PAGE_FLAGS_USER + ; Write (8 byte) entry in the level-2 table + mov [paging_level2_tables + ecx * 8], eax + + ; Increment counter... + inc ecx + ; ... until all four level-2 tables are filled + cmp ecx, 512 * 4 + jne .identitymap_level2 + + + ; The first four entries of the level-3 table should point to the + ; four level-2 tables (and be writeable as well). + ; Again, ECX acts as counter for the loop + mov ecx, 0 + +.identitymap_level3: + ; Calculate the address: ECX * PAGE_SIZE + paging_level2_tables + mov eax, ecx + ; The size of a page is stored in the EDX register + mov edx, PAGE_SIZE + mul edx + add eax, paging_level2_tables + ; Configure attributes + or eax, PAGE_FLAGS_PRESENT | PAGE_FLAGS_WRITEABLE | PAGE_FLAGS_USER + ; Write (8 byte) entry in the level-3 table + mov [paging_level3_table + ecx * 8], eax + + ; Increment counter... + inc ecx + ; ... until all four entries of the table are written + cmp ecx, 4 + jne .identitymap_level3 + + mov eax, paging_level2_tables + or eax, PAGE_FLAGS_PRESENT | PAGE_FLAGS_WRITEABLE | PAGE_FLAGS_USER + mov [paging_level3_table], eax + + ; The first entry of the level-4 table should point to to the level-3 table + mov eax, paging_level3_table + or eax, PAGE_FLAGS_PRESENT | PAGE_FLAGS_WRITEABLE | PAGE_FLAGS_USER + mov [paging_level4_table], eax + + +; Time to activate paging +paging_enable: + ; First setup the control registers + + ; Write the address of the level-4 table into the CR3 register + mov eax, paging_level4_table + mov cr3, eax + + ; Activate Physical Address Extension (PAE) + ; by setting the 5th bits in the CR4 register + mov eax, cr4 + or eax, 1 << 5 + mov cr4, eax + + ; Set the Long Mode Enable Bit in den EFER MSR + ; (Extended Feature Enable Register Model Specific Register) + mov ecx, 0xC0000080 + rdmsr + or eax, 1 << 8 + wrmsr + + ; Finally, the 31st bit in CR0 is set to enable Paging + mov eax, cr0 + or eax, 1 << 31 + mov cr0, eax + + ; Load Long Mode Global Descriptor Table + lgdt [gdt_long_mode_pointer] + + ; Far jump to the 64-bit start code + jmp 0x8:long_mode_start + + ; print `KO` to screen + mov dword [0xb8000], 0x3f4f3f4b + hlt + + +; Memory reserved for page tables +[SECTION .bss] + +align 4096 + +[GLOBAL paging_level4_table] +[GLOBAL paging_level3_table] +[GLOBAL paging_level2_tables] +; 1x Level-4 Table (Page Map Level 4) +paging_level4_table: + resb PAGE_SIZE + +; 1x Level-3 Table (Page Directory Pointer Table) +paging_level3_table: + resb PAGE_SIZE + +; 4x Level-2 Table (Page Directory) +paging_level2_tables: + resb PAGE_SIZE * 4 + +[SECTION .text] +[EXTERN kernel_init] ; C++ entry function + +; Continue with 64 bit code +[BITS 64] + +long_mode_start: + ; Zero all segment register + mov ax, 0x0 + mov ss, ax + mov ds, ax + mov es, ax + mov fs, ax + mov gs, ax + + ; Call high-level (C++) kernel initialization function + call kernel_init + + ; Print `STOP` to screen and stop + mov rax, 0x2f502f4f2f544f53 + mov qword [0xb8000], rax + hlt diff --git a/kernel/boot/multiboot/config.inc b/kernel/boot/multiboot/config.inc new file mode 100644 index 0000000..0ac635c --- /dev/null +++ b/kernel/boot/multiboot/config.inc @@ -0,0 +1,22 @@ +; Magic Header, has to be present in Kernel to indicate Multiboot compliance +MULTIBOOT_HEADER_MAGIC_OS equ 0x1badb002 + +; Answer by the boot loader for Multiboot compliance, written in eax register +MULTIBOOT_HEADER_MAGIC_LOADER equ 0x2badb002 + +; Flags instructing the Multiboot compliant boot loader to setup the system +; according to your needs +MULTIBOOT_PAGE_ALIGN equ 1<<0 ; Align boot modules (initrds) at 4 KiB border +MULTIBOOT_MEMORY_INFO equ 1<<1 ; Request Memory Map information +MULTIBOOT_VIDEO_MODE equ 1<<2 ; Configure video mode + +MULTIBOOT_HEADER_FLAGS equ 0 + +; Desired video mode (only considered if MULTIBOOT_VIDEO_MODE set) +; (boot loader will choose the best fitting mode, which might differ from the settings below) +MULTIBOOT_VIDEO_WIDTH equ 1920 ; Desired width +MULTIBOOT_VIDEO_HEIGHT equ 1080 ; Desired height +MULTIBOOT_VIDEO_BITDEPTH equ 32 ; Desired bit depth + +; Checksum +MULTIBOOT_HEADER_CHKSUM equ -(MULTIBOOT_HEADER_MAGIC_OS + MULTIBOOT_HEADER_FLAGS) diff --git a/kernel/boot/multiboot/data.cc b/kernel/boot/multiboot/data.cc new file mode 100644 index 0000000..0bcaba3 --- /dev/null +++ b/kernel/boot/multiboot/data.cc @@ -0,0 +1,160 @@ +#include "./data.h" + +/*! \brief Multiboot Information Structure according to Specification + * \see [Multiboot Specification]{@ref multiboot} + */ +struct multiboot_info { + /*! \brief Helper Structure + */ + struct Array { + uint32_t size; ///< Length + uint32_t addr; ///< Begin (physical address) + } __attribute__((packed)); + + enum Flag : uint32_t { + Memory = 1 << 0, ///< is there basic lower/upper memory information? + BootDev = 1 << 1, ///< is there a boot device set? + CmdLine = 1 << 2, ///< is the command-line defined? + Modules = 1 << 3, ///< are there modules to do something with? + /* These next two are mutually exclusive */ + SymbolTable = 1 << 4, ///< is there an a.out symbol table loaded? + SectionHeader = 1 << 5, ///< is there an ELF section header table? + + MemoryMap = 1 << 6, ///< is there a full memory map? + DriveInfo = 1 << 7, ///< Is there drive info? + ConfigTable = 1 << 8, ///< Is there a config table? + BootLoaderName = 1 << 9, ///< Is there a boot loader name? + ApmTable = 1 << 10, ///< Is there a APM table? + + // Is there video information? + VbeInfo = 1 << 11, ///< Vesa bios extension + FramebufferInfo = 1 << 12 ///< Framebuffer + } flags; + + /*! \brief Available memory retrieved from BIOS + */ + struct { + uint32_t lower; ///< Amount of memory below 1 MiB in kilobytes + uint32_t upper; ///< Amount of memory above 1 MiB in kilobytes + } mem __attribute__((packed)); + uint32_t boot_device; ///< "root" partition + uint32_t cmdline; ///< Kernel command line + Array mods; ///< List of boot modules + union { + /*! \brief Symbol table for kernel in a.out format + */ + struct { + uint32_t tabsize; + uint32_t strsize; + uint32_t addr; + uint32_t reserved; + } aout_symbol_table __attribute__((packed)); + + /*! \brief Section header table for kernel in ELF + */ + struct { + uint32_t num; ///< Number of entries + uint32_t size; ///< Size per entry + uint32_t addr; ///< Start of the header table + uint32_t shndx; ///< String table index + } elf_section_header_table __attribute__((packed)); + }; + + struct Array mmap; ///< Memory Map + struct Array drives; ///< Drive Information + uint32_t config_table; ///< ROM configuration table + uint32_t boot_loader_name; ///< Boot Loader Name + uint32_t apm_table; ///< APM table + + struct Multiboot::VBE vbe; ///< VBE Information + struct Multiboot::Framebuffer framebuffer; ///< Framebuffer information + + /*! \brief Check if setting is available + * \param flag Flag to check + * \return `true` if available + */ + bool has(enum Flag flag) const { return (flags & flag) != 0; } +} __attribute__((packed)); +assert_size(multiboot_info, 116); + +/*! \brief The pointer to the multiboot structures will be assigned in the + * assembler startup code (multiboot.inc) + */ +struct multiboot_info *multiboot_addr = 0; + +namespace Multiboot { +Module *getModule(unsigned i) { + if (multiboot_addr != nullptr && + multiboot_addr->has(multiboot_info::Flag::Modules) && + i < multiboot_addr->mods.size) { + return i + reinterpret_cast( + static_cast(multiboot_addr->mods.addr)); + } else { + return nullptr; + } +} + +unsigned getModuleCount() { return multiboot_addr->mods.size; } + +void *Memory::getStartAddress() const { + return reinterpret_cast(static_cast(addr)); +} + +void *Memory::getEndAddress() const { + uint64_t end = addr + len; + return reinterpret_cast(static_cast(end)); +} + +bool Memory::isAvailable() const { return type == AVAILABLE; } + +Memory *Memory::getNext() const { + if (multiboot_addr != nullptr && + multiboot_addr->has(multiboot_info::Flag::MemoryMap)) { + uintptr_t next = + reinterpret_cast(this) + size + sizeof(size); + if (next < multiboot_addr->mmap.addr + multiboot_addr->mmap.size) { + return reinterpret_cast(next); + } + } + return nullptr; +} + +Memory *getMemoryMap() { + if (multiboot_addr != nullptr && + multiboot_addr->has(multiboot_info::Flag::MemoryMap) && + multiboot_addr->mmap.size > 0) { + return reinterpret_cast( + static_cast(multiboot_addr->mmap.addr)); + } else { + return nullptr; + } +} + +char *getCommandLine() { + return reinterpret_cast( + static_cast(multiboot_addr->cmdline)); +} + +char *getBootLoader() { + return reinterpret_cast( + static_cast(multiboot_addr->boot_loader_name)); +} + +VBE *getVesaBiosExtensionInfo() { + if (multiboot_addr != nullptr && + multiboot_addr->has(multiboot_info::Flag::VbeInfo)) { + return &(multiboot_addr->vbe); + } else { + return nullptr; + } +} + +Framebuffer *getFramebufferInfo() { + if (multiboot_addr != nullptr && + multiboot_addr->has(multiboot_info::Flag::FramebufferInfo)) { + return &(multiboot_addr->framebuffer); + } else { + return nullptr; + } +} +} // namespace Multiboot diff --git a/kernel/boot/multiboot/data.h b/kernel/boot/multiboot/data.h new file mode 100644 index 0000000..b875370 --- /dev/null +++ b/kernel/boot/multiboot/data.h @@ -0,0 +1,229 @@ +/*! \file + * \brief \ref Multiboot Interface + */ +#pragma once +#include "../../debug/assert.h" +#include "../../types.h" + +/*! \brief Interface for Multiboot + * + * Due to historical reasons, a normal BIOS allows you to do quite an egg dance + * until you finally reach the actual kernel (especially with only 512 bytes + * available in the master boot record...). + * Fortunately, there are [boot loaders](https://wiki.osdev.org/Bootloader) that + * (partly) do this ungrateful job for you: + * They load your kernel into memory, switch (the bootstrap processor) to + * protected mode (32 bit) and jump to the entry point of our kernel -- saving + * you a lot of boring (or enlightening?) work: reading ancient systems + * documentation. One of the most famous representatives is the [Grand Unified + * Bootloader (GRUB)](https://www.gnu.org/software/grub/), which is also the + * reference implementation of the [Multiboot Specification]{@ref multiboot}. + * + * A Multiboot compliant boot loader will prepare the system according to your + * needs and can hand you a lot of useful information (e.g. references to + * initial ramdisks). + * + * However, you have to inform the loader that you are also compliant to the + * specification, and (if required) instruct the loader to adjust specific + * settings (e.g. the graphics mode). + * + * For this purpose you have to configure the beginning of the kernel (the first + * 8192 bytes of the kernel binary) accordingly (see `compiler/section.ld`) -- + * this is were the boot loader will search for a magic header and parse the + * subsequent entries containing the desired system configuration. + * In StuBS these flags are set in `boot/multiboot/config.inc` and the header + * structure is generated in `boot/multiboot/header.asm`. + * + * The first step in your \ref startup_bsp() "kernel entry function" is saving + * the pointer to the struct with the information from the boot loader + * (transferred via register `ebx`) -- and \ref Multiboot provides you the + * interface to comfortably access its contents! + */ +namespace Multiboot { +/*! \brief Boot Module + * (also known as `initrd` = initial Ramdisk) + * + * \see [1.7 Boot modules]{@ref multiboot} + * \see [3.3 Boot information format]{@ref multiboot} + */ +class Module { + uint32_t start; ///< Start address + uint32_t end; ///< End address (excluded) + uint32_t cmdline; ///< commandline parameter + uint32_t pad [[maybe_unused]]; ///< alignment; must be 0 + + public: + /*! \brief Get start of this boot module + * \return Pointer to begin of modules physical address + */ + void* getStartAddress() const { + return reinterpret_cast(static_cast(start)); + } + + /*! \brief Get end of this boot module + * \return Pointer beyond the modules physical address + */ + void* getEndAddress() const { + return reinterpret_cast(static_cast(end)); + } + + /*! \brief Get the size of this boot module + * \return Module size in bytes (difference of end and start address) + */ + size_t getSize() const { return static_cast(end - start); } + + /*! \brief Get the command line for this module + * \return pointer to zero terminated string + */ + char* getCommandLine() const { + return reinterpret_cast(static_cast(cmdline)); + } +} __attribute__((packed)); +assert_size(Module, 16); + +/*! \brief Retrieve a certain boot module + * \param i boot module number + * \return Pointer to structure with boot module information + */ +Module* getModule(unsigned i); + +/*! \brief Get the number of modules + * \return Pointer to structure with boot module information + */ +unsigned getModuleCount(); + +/*! \brief Get the kernel command line + * \return pointer to zero terminated string + */ +char* getCommandLine(); + +/*! \brief Get the name of the boot loader + * \return pointer to zero terminated string + */ +char* getBootLoader(); + +/*! \brief Memory Map + * + * The boot loader queries the BIOS for a memory map and stores its result in + * (something like) a linked list. However, this list may not be complete, + * can have contradictory entries and does not take the location of your kernel + * or any boot modules into account. + * (Anyways, it is still the best memory map you will have in StuBS...) + * + * \note Needs to be enabled explicitly by setting the `MULTIBOOT_MEMORY_INFO` + * flag in the multiboot header (see `boot/multiboot/config.inc`)! + * + * \see [Detecting Memory](https://wiki.osdev.org/Detecting_Memory_(x86)) + */ +class Memory { + uint32_t size; ///< Size of this entry (can exceed size of the class, rest + ///< will be padding bits) + uint64_t addr; ///< Begin of memory area + uint64_t len; ///< length of the memory area + + /*! \brief Usage Type + */ + enum Type : uint32_t { + AVAILABLE = 1, ///< Memory is available and usable in kernel + RESERVED = 2, ///< Memory is reserved (without further explanation) + ACPI = 3, ///< Memory may be reclaimed by ACPI + NVS = 4, ///< Memory is non volatile storage for ACPI + BADRAM = 5 ///< Area contains bad memory + } type; + + public: + /*! \brief Get start of this memory area + * \return Pointer to begin of the physical address of the memory area + */ + void* getStartAddress() const; + + /*! \brief Get end of this memory area + * \return Pointer beyond the physical address of this memory area + */ + void* getEndAddress() const; + + /*! \brief Is the memory marked as usable + * \return `true` if available, `false` if not usable. + */ + bool isAvailable() const; + + /*! \brief Get the next memory area + * \return pointer to the next memory area entry + */ + Memory* getNext() const; +} __attribute__((packed)); +assert_size(Memory, 24); + +/*! \brief Retrieve the first entry of the memory map + */ +Memory* getMemoryMap(); + +/*! \brief Video mode: Vesa BIOS Extension + * + * \see [VESA BIOS Extension (VBE) Core Functions (Version 3)](vbe3.pdf) + */ +struct VBE { + uint32_t control_info; ///< Pointer to VBE control information + uint32_t mode_info; ///< Pointer to VBE mode information + uint16_t mode; ///< Selected video mode (as defined in the standard) + uint16_t interface_seg; ///< Protected mode interface (unused) + uint16_t interface_off; ///< Protected mode interface (unused) + uint16_t interface_len; ///< Protected mode interface (unused) +} __attribute__((packed)); +assert_size(VBE, 16); + +/*! \brief Get pointer to Vesa BIOS Extension information + * + * \note Only available if the `MULTIBOOT_VIDEO_MODE` flag was explicitly set + * in the multiboot header (see `boot/multiboot/config.inc`)! + */ +VBE* getVesaBiosExtensionInfo(); + +/*! \brief Video mode: Framebuffer + * + * This beautiful structure contains everything required for using the graphic + * framebuffer in a very handy manner -- however, it may not be well supported + * by current boot loaders... + * These information can be retrieved from \ref VBE as well, though you then + * have to parse these huge structures containing a lot of useless stuff. + */ +struct Framebuffer { + uint64_t address; ///< Physical address of the framebuffer + uint32_t pitch; ///< Number of bytes per row + uint32_t width; ///< Width of framebuffer + uint32_t height; ///< Height of framebuffer + uint8_t bpp; ///< Bits per pixel + enum Type : uint8_t { + INDEXED = 0, ///< Using a custom color palette + RGB = 1, ///< Standard red-green-blue + EGA_TEXT = 2 ///< Enhanced Graphics Adapter color palette + } type; + union { + /*! \brief For INDEXED type + */ + struct { + uint32_t palette_addr; ///< Address of an array with RGB values + uint16_t palette_num_colors; ///< Number of colors (in array above) + } __attribute__((packed)); + + /*! \brief For RGB type + */ + struct { + uint8_t offset_red; ///< Offset of red value + uint8_t bits_red; ///< Bits used in red value + uint8_t offset_green; ///< Offset of green value + uint8_t bits_green; ///< Bits used in green value + uint8_t offset_blue; ///< Offset of blue value + uint8_t bits_blue; ///< Bits used in blue value + } __attribute__((packed)); + } __attribute__((packed)); +} __attribute__((packed)); +assert_size(Framebuffer, 28); + +/*! \brief Get pointer to framebuffer information + * + * \note Only available if the `MULTIBOOT_VIDEO_MODE` flag was explicitly set + * in the multiboot header (see `boot/multiboot/config.inc`)! + */ +Framebuffer* getFramebufferInfo(); +} // namespace Multiboot diff --git a/kernel/boot/multiboot/header.asm b/kernel/boot/multiboot/header.asm new file mode 100644 index 0000000..70f5117 --- /dev/null +++ b/kernel/boot/multiboot/header.asm @@ -0,0 +1,33 @@ +; The first 8192 bytes of the kernel binary must contain a header with +; predefined (and sometimes "magic") values according to the Multiboot standard. +; Based on these values, the boot loader decides whether and how to load the +; kernel -- which is compiled and linked into an ELF file. +; To make this possible with your StuBS kernel, the linker places the following +; entry `multiboot_header` at the very beginning of the file thanks to the +; linker script (located in compiler/sections.ld). + +[SECTION .multiboot_header] + +; Include configuration +%include 'boot/multiboot/config.inc' + +; Multiboot Header +align 4 +multiboot_header: + dd MULTIBOOT_HEADER_MAGIC_OS ; Magic Header Value + dd MULTIBOOT_HEADER_FLAGS ; Flags (affects following entries) + dd MULTIBOOT_HEADER_CHKSUM ; Header Checksum + + ; Following fields would have been required to be defined + ; if flag A_OUT KLUDGE was set (but we don't need this) + dd 0 ; Header address + dd 0 ; Begin of load address + dd 0 ; end of load address + dd 0 ; end of bss segment + dd 0 ; address of entry function + + ; Following fields are required for video mode (flag MULTIBOOT_VIDEO_MODE) + dd 0 ; Mode: 0 = Graphic / 1 = Text + dd MULTIBOOT_VIDEO_WIDTH ; Width (pixels / columns) + dd MULTIBOOT_VIDEO_HEIGHT ; Height (pixels / rows) + dd MULTIBOOT_VIDEO_BITDEPTH ; color depth / number of colors diff --git a/kernel/boot/startup.asm b/kernel/boot/startup.asm new file mode 100644 index 0000000..db26aa0 --- /dev/null +++ b/kernel/boot/startup.asm @@ -0,0 +1,78 @@ +; This is the actual entry point of the kernel. +; The switch into the 32-bit 'Protected Mode' has already been performed +; (by the boot loader). +; The assembly code just performs the absolute necessary steps (like setting up +; the stack) to be able to jump into the C++ code -- and continue further +; initialization in a (more) high-level language. + +[BITS 32] + +; External functions and variables +[EXTERN CPU_CORE_STACK_SIZE] ; Constant containing the initial stack size (per CPU core), see `arch/core.cc` +[EXTERN cpu_core_stack_pointer] ; Pointer to reserved memory for CPU core stacks, see `arch/core.cc` +[EXTERN gdt_protected_mode_pointer] ; Pointer to 32 Bit Global Descriptor Table (located in `arch/gdt.cc`) +[EXTERN long_mode] ; Low level function to jump into the 64-bit mode ('Long Mode', see `boot/longmode.asm`) +[EXTERN multiboot_addr] ; Variable, in which the Pointer to Multiboot information + ; structure should be stored (`boot/multiboot/data.cc`) + +; Load Multiboot settings +%include "boot/multiboot/config.inc" + +[SECTION .text] + +; Entry point for the bootstrap processor (CPU0) +[GLOBAL startup_bsp] +startup_bsp: + ; Check if kernel was booted by a Multiboot compliant boot loader + cmp eax, MULTIBOOT_HEADER_MAGIC_LOADER + jne skip_multiboot + ; Pointer to Multiboot information structure has been stored in ebx by the + ; boot loader -- copy to a variable for later usage. + mov [multiboot_addr], ebx + +skip_multiboot: + ; Disable interrupts + cli + ; Disable non maskable interrupts (NMI) + ; (we are going to ignore them) + mov al, 0x80 + out 0x70, al + + jmp load_cs + + +; Segment initialization +; (code used by bootstrap and application processors as well) +[GLOBAL segment_init] +segment_init: + ; Load temporary protected mode Global Descriptor Table (GDT) + lgdt [gdt_protected_mode_pointer] + + ; Initialize segment register + mov ax, 0x10 + mov ds, ax + mov es, ax + mov fs, ax + mov gs, ax + mov ss, ax + + ; Load code segment register + jmp 0x8:load_cs + +load_cs: + ; Initialize stack pointer: + ; Atomic increment of `cpu_core_stack_pointer` by `CPU_CORE_STACK_SIZE` + ; (to avoid race conditions at application processor boot) + mov eax, [CPU_CORE_STACK_SIZE] + lock xadd [cpu_core_stack_pointer], eax + ; Since the stack grows into the opposite direction, + ; Add `CPU_CORE_STACK_SIZE` again + add eax, [CPU_CORE_STACK_SIZE] + ; Assign stack pointer + mov esp, eax + + ; Clear direction flag for string operations + cld + + ; Switch to long mode (64 bit) + jmp long_mode diff --git a/kernel/boot/startup.cc b/kernel/boot/startup.cc new file mode 100644 index 0000000..96c9e29 --- /dev/null +++ b/kernel/boot/startup.cc @@ -0,0 +1,49 @@ +#include "startup.h" + +#include "../arch/acpi.h" +#include "../arch/apic.h" +#include "../arch/core.h" +#include "../arch/idt.h" +#include "../arch/pic.h" +#include "../compiler/libc.h" +#include "../debug/output.h" +#include "../interrupt/handlers.h" + +extern "C" [[noreturn]] void kernel_init() { + // Setup and load Interrupt Description Table (IDT) + initInterruptHandlers(); + + // Initialize PICs + PIC::initialize(); + + // Call global constructors + CSU::initializer(); + + // Initialize ACPI + if (!ACPI::init()) { + DBG_VERBOSE << "No ACPI!"; + Core::die(); + } + // Initialize APIC (using ACPI) + if (!APIC::init()) { + DBG_VERBOSE << "APIC Initialization failed"; + Core::die(); + } + + // Initialize the Bootstrap Processor + Core::init(); + + // Go to main function + main(); + + // Exit CPU + DBG_VERBOSE << "CPU core " << Core::getID() << " (BSP) shutdown." << endl; + Core::exit(); + // Call global destructors + CSU::finalizer(); + + // wait forever + while (true) { + Core::die(); + } +} diff --git a/kernel/boot/startup.h b/kernel/boot/startup.h new file mode 100644 index 0000000..e835c02 --- /dev/null +++ b/kernel/boot/startup.h @@ -0,0 +1,35 @@ +/*! \file + * \brief Startup of the first core, also known as bootstrap processor (BSP) + * \defgroup Startup "Bootloader and system startup" + * + */ +#pragma once +#include "../types.h" + +/*! \brief Entry point of your kernel + * + * \ingroup Startup + * + * Executed by boot loader. + * Stores Pointer to \ref Multiboot information structure, + * initializes stack pointer, + * switches to long mode + * and finally calls the C++ \ref kernel_init function + */ +extern "C" void startup_bsp(); + +/*! \brief Initializes the C++ environment and detects system components + * + * \ingroup Startup + * + * The startup code TEMPLATE(m){(both for \ref startup_bsp "bootstrap" and \ref + * startup_ap "application processor")} jumps to this high level function. After + * initialization it will call \ref main() + */ +extern "C" [[noreturn]] void kernel_init(); + +/*! \brief Kernels main function + * + * Called after initialization of the system by \ref kernel_init() + */ +extern "C" int main(); diff --git a/kernel/compiler/libc.cc b/kernel/compiler/libc.cc new file mode 100644 index 0000000..5b6009d --- /dev/null +++ b/kernel/compiler/libc.cc @@ -0,0 +1,46 @@ +#include "libc.h" + +/*! \brief Function pointer for initialization/finalization functions for global + * objects required since GCC 4.7 and later. + * + * These symbols appear kind of magically due to the compiler + */ +extern void (*__preinit_array_start[])(); +extern void (*__preinit_array_end[])(); +extern void (*__init_array_start[])(); +extern void (*__init_array_end[])(); +extern void (*__fini_array_start[])(); +extern void (*__fini_array_end[])(); + +namespace CSU { + +void initializer() { + const unsigned int preinit_size = + __preinit_array_end - __preinit_array_start; + for (unsigned int i = 0; i != preinit_size; ++i) { + (*__preinit_array_start[i])(); + } + + const size_t size = __init_array_end - __init_array_start; + for (size_t i = 0; i < size; i++) { + (*__init_array_start[i])(); + } +} + +void finalizer() { + const unsigned int fini_size = __fini_array_end - __fini_array_start; + for (unsigned int i = 0; i != fini_size; ++i) { + (*__fini_array_start[i])(); + } +} + +} // namespace CSU + +extern "C" int atexit(void (*func)(void)) { + // Registers a function that will be executed on exit. + // We simply ignore those functions, as we don't need them for our operating + // systems. + (void)func; + + return 0; +} diff --git a/kernel/compiler/libc.h b/kernel/compiler/libc.h new file mode 100644 index 0000000..4aa11fc --- /dev/null +++ b/kernel/compiler/libc.h @@ -0,0 +1,23 @@ +/*! \file + * \brief Initialization functions for global objects required by the compiler + */ + +#pragma once +#include "types.h" + +/*! \brief C StartUp (CSU) + * required by the compiler and provided by the c standard library + */ +namespace CSU { + +/*! \brief Call global constructors and initialization functions + * (this is usually done by __libc_csu_init) + */ +void initializer(); + +/*! \brief Call global destructors and finalizer functions + * (this is usually done by __libc_csu_fini) + */ +void finalizer(); + +} // namespace CSU diff --git a/kernel/compiler/libcxx.cc b/kernel/compiler/libcxx.cc new file mode 100644 index 0000000..6330535 --- /dev/null +++ b/kernel/compiler/libcxx.cc @@ -0,0 +1,33 @@ +/*! \file + * \brief C++ runtime support functions + */ + +#include "../debug/assert.h" +#include "../types.h" + +void* operator new([[maybe_unused]] size_t size, void* place) { return place; } + +void* operator new(size_t size) { + (void)size; + assert(!"Memory allocation not supported"); +} + +void* operator new[](size_t size) { + (void)size; + assert(!"Memory allocation not supported"); +} + +void operator delete(void* ptr) { (void)ptr; } +void operator delete(void* ptr, [[maybe_unused]] size_t size) { + operator delete(ptr); +} + +void operator delete[](void* ptr) { operator delete(ptr); } +void operator delete[](void* ptr, size_t size) { operator delete(ptr, size); } + +extern "C" [[noreturn]] void __cxa_pure_virtual() { + // Pure virtual function was called -- this if obviously not valid, + // therefore we wait infinitely. + while (true) { + } +} diff --git a/kernel/compiler/sections.ld b/kernel/compiler/sections.ld new file mode 100644 index 0000000..cfc7870 --- /dev/null +++ b/kernel/compiler/sections.ld @@ -0,0 +1,106 @@ +/* Entry in our OS -- label 'startup_bsp' in file boot/startup.asm */ +ENTRY(startup_bsp) + +SECTIONS + { + /* start address of our kernel */ + . = 16M; + + ___KERNEL_START___ = .; + + .boot : + { + /* Multiboot Header should be at the very beginning */ + *(.multiboot_header) + } + + + .text : + { + *(".text") + *(".text$") + *(".init") + *(".fini") + *(".gnu.linkonce.*") + KEEP(*(.note.gnu.build-id)) + } + + /* lists containing the start address of global constructors and destructors (generated by the compiler) */ + .preinit_array : + { + PROVIDE_HIDDEN (__preinit_array_start = .); + KEEP (*(.preinit_array)) + PROVIDE_HIDDEN (__preinit_array_end = .); + } + .init_array : + { + PROVIDE_HIDDEN (__init_array_start = .); + KEEP (*(SORT(.init_array.*))) + KEEP (*(.init_array)) + PROVIDE_HIDDEN (__init_array_end = .); + } + .fini_array : + { + PROVIDE_HIDDEN (__fini_array_start = .); + KEEP (*(SORT(.fini_array.*))) + KEEP (*(.fini_array)) + PROVIDE_HIDDEN (__fini_array_end = .); + } + + + .data : + { + *(".data") + *(".data$") + *(".rodata") + ___CTOR_LIST__ = .; + *(".ctors") + *(".ctor") + ___CTOR_LIST_END__ = .; + ___DTOR_LIST__ = .; + *(".dtors") + *(".dtor") + ___DTOR_LIST_END__ = .; + *(".got") + *(".got.plt") + *(".eh_frame") + *(".eh_fram") + *(".jcr") + } + + /* Start for application processors, relocated by APIC::init() + * to a below 1 MB address to boot from real mode. + * It is possible to let the linker place it at a below 1 MB address, + * while all the rest starts at 16 MB. This will work for multiboot + * compliant boot loader like GRUB and PXELINUX, however, + * the qemu boot loader cannot handle such ELF files (yet)... + * That's why we have to do it in our software */ + .setup_ap_seg ALIGN(0x10) : + { + ___SETUP_AP_START__ = .; + *(".setup_ap_seg") + *(".setup_ap_seg$") + } + ___SETUP_AP_END__ = .; + + .bss : + { + *(".bss") + *(".bss.*") + *(COMMON) + } + ___KERNEL_END___ = .; + + + /DISCARD/ : + { + *(".note") + *(".comment") +/* Keep debug information + *(".debug_line") + *(".debug_info") + *(".debug_abbrev") + *(".debug_aranges") +*/ + } + } diff --git a/kernel/debug/assert.cc b/kernel/debug/assert.cc new file mode 100644 index 0000000..678e3c5 --- /dev/null +++ b/kernel/debug/assert.cc @@ -0,0 +1,11 @@ +#include "assert.h" + +#include "../arch/core.h" +#include "output.h" + +[[noreturn]] void assertion_failed(const char* exp, const char* func, + const char* file, int line) { + DBG << "Assertion '" << exp << "' failed (" << func << " @ " << file << ":" + << dec << line << ") - CPU stopped." << endl; + Core::die(); +} diff --git a/kernel/debug/assert.h b/kernel/debug/assert.h new file mode 100644 index 0000000..d6546b7 --- /dev/null +++ b/kernel/debug/assert.h @@ -0,0 +1,74 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief Contains several macros usable for making assertions + * + * Depending on the type of assertion (either static or at runtime), a failing + * assertion will trigger an error. For static assertion, this error will be + * shown at compile time and abort compilation. Runtime assertions will trigger + * a message containing details about the error occurred and will make the CPU + * die. + */ + +/*! + * \defgroup debug Debugging functions + */ + +#pragma once +#include "../types.h" + +#ifndef STRINGIFY +/*! \def STRINGIFY(S) + * \brief Converts a macro parameter into a string + * \ingroup debug + * \param S Expression to be converted + * \return stringified version of S + */ +#define STRINGIFY(S) #S +#endif + +/*! \def assert_size(TYPE, SIZE) + * \brief Statically ensure (at compile time) that a data type (or variable) + * has the expected size. + * + * \ingroup debug + * \param TYPE The type to be checked + * \param SIZE Expected size in bytes + */ +#define assert_size(TYPE, SIZE) \ + static_assert(sizeof(TYPE) == (SIZE), "Wrong size for " STRINGIFY(TYPE)) + +/*! \def assert(EXP) + * \brief Ensure (at execution time) an expression evaluates to `true`, print + * an error message and stop the CPU otherwise. + * + * \ingroup debug + * \param EXP The expression to be checked + */ +#ifdef NDEBUG +#define assert(EXP) ((void)0) +#else +#define assert(EXP) \ + do { \ + if (__builtin_expect(!(EXP), 0)) { \ + assertion_failed(STRINGIFY(EXP), __func__, __FILE__, __LINE__); \ + } \ + } while (false) + +/*! \brief Handles a failed assertion + * + * This function will print a message containing further information about the + * failed assertion and stops the current CPU permanently. + * + * \note This function should never be called directly, but only via the macro + * `assert`. + * + * + * \param exp Expression that did not hold + * \param func Name of the function in which the assertion failed + * \param file Name of the file in which the assertion failed + * \param line Line in which the assertion failed + */ +[[noreturn]] void assertion_failed(const char* exp, const char* func, + const char* file, int line); +#endif diff --git a/kernel/debug/copystream.h b/kernel/debug/copystream.h new file mode 100644 index 0000000..f4c422d --- /dev/null +++ b/kernel/debug/copystream.h @@ -0,0 +1,44 @@ +/*! \file + * \brief \ref CopyStream duplicates \ref OutputStream "output streams" + */ + +#pragma once +#include "../object/outputstream.h" +#include "../types.h" + +/*! \brief Duplicate all data passed by the stream operator to two \ref + * OutputStream "output streams" + * \ingroup io + * + * Can be used as replacement for any \ref OutputStream -- for example, + * forwarding the \ref DBG output simultaneously to screen (\ref TextStream) and + * serial console (\ref SerialStream). + * + */ +class CopyStream : public OutputStream { + /*! \brief First recipient + */ + OutputStream* first; + + /*! \brief Second recipient + */ + OutputStream* second; + + public: + /*! \brief Constructor + * + * \param first First recipient for output passed to this object + * \param second Second recipient for output passed to this object + */ + CopyStream(OutputStream* first, OutputStream* second) + : first(first), second(second) {} + + /*! \brief Redirect the buffer to both streams and flush them, too. + */ + void flush() override { + buffer[pos] = '\0'; // make sure buffer will only be printed until pos. + *first << buffer << ::flush; + *second << buffer << ::flush; + pos = 0; + } +}; diff --git a/kernel/debug/kernelpanic.h b/kernel/debug/kernelpanic.h new file mode 100644 index 0000000..bce7af6 --- /dev/null +++ b/kernel/debug/kernelpanic.h @@ -0,0 +1,27 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief Macro to print an error message and stop the current core. + */ + +#pragma once +#include "../types.h" + +/*! \def kernelpanic + * \brief Print an error message in the debug window and \ref Core::die "stop + * the current core" + * + * \param MSG error message + * \ingroup debug + */ +#define kernelpanic(MSG) \ + do { \ + DBG << "PANIC: '" << (MSG) << "' in " << __func__ << " @ " << __FILE__ \ + << ":" << __LINE__ << ") - CPU stopped." << endl; \ + Core::die(); \ + } while (0) + +// The includes are intentionally placed at the end, so the macro can be used +// inside those included files as well. +#include "../arch/core.h" +#include "./output.h" diff --git a/kernel/debug/nullstream.cc b/kernel/debug/nullstream.cc new file mode 100644 index 0000000..1cba8b9 --- /dev/null +++ b/kernel/debug/nullstream.cc @@ -0,0 +1,4 @@ +#include "nullstream.h" + +// Instance +NullStream nullstream; diff --git a/kernel/debug/nullstream.h b/kernel/debug/nullstream.h new file mode 100644 index 0000000..2c90599 --- /dev/null +++ b/kernel/debug/nullstream.h @@ -0,0 +1,45 @@ +/*! \file + * \brief \ref NullStream is a stream discarding everything + */ + +#pragma once +#include "../object/outputstream.h" +#include "../types.h" + +/*! \brief Ignore all data passed by the stream operator + * \ingroup io + * + * Can be used instead of the \ref OutputStream if (for debugging reasons) all + * output should be ignored, e.g. for \ref DBG_VERBOSE + * + * By using template programming, a single generic methods is sufficient + * (which simply discard everything). + */ +class NullStream { + /*! \brief Check if type is supported by output stream + */ + template + auto check(T v, OutputStream* p = nullptr) -> decltype(*p << v, void()) {} + + public: + /*! \brief Empty default constructor + */ + NullStream() {} + + /*! \brief Generic stream operator for any data type + * + * Uses template meta programming for a generic & short solution + * + * \tparam T Type of data to ignore + * \param value data to be ignore + * \return Reference to the \ref NullStream object allowing concatenation of + * operators + */ + template + NullStream& operator<<(T value) { + check(value); + return *this; + } +}; + +extern NullStream nullstream; diff --git a/kernel/debug/output.h b/kernel/debug/output.h new file mode 100644 index 0000000..939c3b8 --- /dev/null +++ b/kernel/debug/output.h @@ -0,0 +1,69 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief Debug macros enabling debug output on a separate window for each + * core. + */ + +#pragma once +#include "../object/outputstream.h" +#include "../types.h" +#include "nullstream.h" + +/*! \def DBG_VERBOSE + * \brief An output stream, which is only displayed in the debug window in + * verbose mode + * + * \note If a serial console has been implemented, the output can be redirected + * to the serial stream instead (by changing the macro) -- this makes the + * (usually) very large output more readable (since it allows scrolling + * back) + */ +#ifdef VERBOSE +// If VERBOSE is defined, forward everything to \ref DBG +#define DBG_VERBOSE (DBG << __FILE__ << ":" << __LINE__ << " ") +#else +// Otherwise sent everything to the NullStream (which will simply discard +// everything) +#define DBG_VERBOSE nullstream +#endif + +/*! \def DBG + * \brief An output stream, which is displayed in the debug window + * + * This is also used by the \ref assert macro and its underlying \ref + * assertion_failed method. + * + * In single core (\OOStuBS) this is just an alias to the debug window object + * `dout`. + */ +#define DBG *copyout + +#include "../device/textstream.h" + +/*! \brief Debug window + * + * Debug output using \ref DBG like + * `DBG << "var = " << var << endl` + * should be displayed in separate window. + * + * Ideally, this window should be placed below the normal output window + * without any overlap and be able to display 4 lines. + * + */ +extern TextStream dout; + +/*! \brief Debug window with copy function to serial + * + * Provide an additional layer to also ouput debug prints to serial. + * While this is a simple CopyStream pointer in the single core case, it is + * an array in the multi core case, which consists of three TextStreams and + * one CopyStream. + * For that, construction is done like: + * + * \code{.cpp} + * OutputStream* copyout[Core::MAX]{&dout[0], &dout[1], ...} + * \endcode + * + */ +extern OutputStream* copyout; diff --git a/kernel/device/graphics.cc b/kernel/device/graphics.cc new file mode 100644 index 0000000..9d428d0 --- /dev/null +++ b/kernel/device/graphics.cc @@ -0,0 +1,189 @@ +#include "./graphics.h" + +#include "../boot/multiboot/data.h" +#include "./debug/output.h" +#include "./utils/string.h" + +/// Replace size with `Graphics::SCREEN_BUF_SIZE` +/// We don't do this here, as this drastically increases the size of the kernel +/// image. +char frontbuffer[1] __attribute__((aligned(8))); +char backbuffer[1] __attribute__((aligned(8))); + +/*! \brief Mode Information of the *Vesa BIOS Extension* + * + * \see Vesa BIOS Extension [ModeInfoBlock struc](vbe3.pdf#page=38) + */ +struct VbeModeInfo { + enum ModeAttributes : uint16_t { + SUPPORTED = 1 << 0, ///< Mode supported by hardware configuration + TTY = 1 << 2, ///< TTY Output functions supported by BIOS + COLOR = 1 << 3, ///< Color mode (otherwise monochrome) + GRAPHICS = 1 << 4, ///< Graphic mode (otherwise text) + VGA = 1 << 5, ///< VGA compatible + VGA_PAGED = + 1 << 6, ///< VGA compatible windowed memory mode is available + LFB = 1 << 7, ///< Linear frame buffer mode is available + }; + uint16_t mode_attributes; + + // Window functions (used by all VBE revisions, but ignored here) + struct __attribute__((packed)) { + uint8_t attrib_a; + uint8_t attrib_b; + uint16_t granularity; + uint16_t size; + uint16_t segment_a; + uint16_t segment_b; + uint32_t func_ptr; + } win; + + uint16_t pitch; ///< Bytes per scan line + uint16_t + width; ///< Horizontal resolution in pixels (GRAPHICS) or characters + uint16_t + height; ///< Vertical resolution in pixels (GRAPHICS) or characters + + uint8_t char_width; ///< Character cell width in pixels (deprecated) + uint8_t char_height; ///< Character cell height in pixels (deprecated) + uint8_t planes; ///< Number of memory planes + + uint8_t bpp; ///< Bits per pixel + + uint8_t banks; ///< Number of banks + enum MemoryModel : uint8_t { + TEXT_MODE = 0, ///< Text mode + CGA = 1, ///< CGA graphics + HERCULES = 2, ///< Hercules graphics + PLANAR = 3, ///< Planar + PACKED = 4, ///< Packed pixel + NON_CHAIN_4 = 5, ///< Non-chain 4, 256 color + DIRECT_COLOR = 6, ///< Direct Color + YUV = 7 ///< YUV + } memory_model; ///< Memory model type + uint8_t bank_size; ///< Bank size in KB + uint8_t image_pages; ///< Number of images + uint8_t reserved; ///< Reserved for page function + + // Direct Color fields (required for DIRECT_COLOR and YUV memory models) + uint8_t bits_red; ///< Size of direct color red mask in bits + uint8_t offset_red; ///< Bit position of lsb of red mask + uint8_t bits_green; ///< Size of direct color green mask in bits + uint8_t offset_green; ///< Bit position of lsb of green mask + uint8_t bits_blue; ///< Size of direct color blue mask in bits + uint8_t offset_blue; ///< Bit position of lsb of blue mask + uint8_t bits_rsv; ///< Size of direct color reserved mask in bits + uint8_t offset_rsv; ///< Bit position of lsb of reserved mask + + enum DirectColorAttributes : uint8_t { + DYNAMIC_COLOR_RAMP = + 1 << 0, ///< Programmable (otherwise fixed) color ramp + USABLE_BITS = + 1 << 1 ///< Bits in reserved mask are usable (otherwise reserved) + }; + uint8_t directcolor_attributes; ///< direct color mode attributes + + // Mandatory information for VBE 2.0 and above + uint32_t address; ///< physical address for flat memory frame buffer + uint32_t offscreen_memory_offset; ///< reserved + uint16_t offscreen_memory_size; ///< reserved +} __attribute__((packed)); + +Graphics::Graphics() + : buffer_size(SCREEN_BUF_SIZE), + buffer{frontbuffer, backbuffer}, + scanout_buffer(0), + refresh(false) {} + +bool Graphics::init(bool force) { + assert(sizeof(frontbuffer) >= buffer_size && + sizeof(backbuffer) >= buffer_size && + "Buffers are too small, adjust them!!!"); + // Most boot loaders support the Vesa BIOS Extension (VBE) information quite + // well + Multiboot::VBE *vbe = Multiboot::getVesaBiosExtensionInfo(); + if (vbe != nullptr) { + // However, you have to manually parse the required data out of all the + // outdated crap + struct VbeModeInfo *vbe_info = reinterpret_cast( + static_cast(vbe->mode_info)); + // Is there linear frame buffer (or just ignore the check with `force` + // due to a misleading information)? + if (force || (vbe_info->mode_attributes & + VbeModeInfo::ModeAttributes::LFB) != 0) { + // Is there a suitable precompiled graphic mode + printer = AbstractGraphicsPrinter::getMode( + vbe_info->bpp, vbe_info->offset_red, vbe_info->offset_green, + vbe_info->offset_blue, vbe_info->bits_red, vbe_info->bits_green, + vbe_info->bits_blue); + if (printer != nullptr) { + address = reinterpret_cast( + static_cast(vbe_info->address)); + size = vbe_info->height * vbe_info->pitch; + if (size > buffer_size) { + DBG_VERBOSE << "The current graphic buffer (" << buffer_size + << " bytes) is too small (at least " << size + << " bytes required)!" << endl; + return false; + } else { + printer->init(vbe_info->width, vbe_info->height, + vbe_info->pitch); + printer->buffer(buffer[1 - scanout_buffer]); + return true; + } + } + } else { + DBG_VERBOSE << "Unsupported graphic mode" << endl; + } + } + + // Actually, \ref Multiboot::Framebuffer has everything we need in a real + // smart structure, however boot loader like PXE don't support them (yet -- + // quite new, added in the last Multiboot revision). + Multiboot::Framebuffer *fb = Multiboot::getFramebufferInfo(); + if (fb != nullptr) { + if (force || fb->type == Multiboot::Framebuffer::RGB) { + printer = AbstractGraphicsPrinter::getMode( + fb->bpp, fb->offset_red, fb->offset_green, fb->offset_blue, + fb->bits_red, fb->bits_green, fb->bits_blue); + if (printer != nullptr) { + address = reinterpret_cast( + static_cast(fb->address)); + size = fb->height * fb->pitch; + if (size > buffer_size) { + DBG_VERBOSE << "The current graphic buffer (" << buffer_size + << " bytes) is too small (at least " << size + << " bytes required)!" << endl; + return false; + } else { + printer->init(fb->width, fb->height, fb->pitch); + printer->buffer(buffer[1 - scanout_buffer]); + return true; + } + } + } else { + DBG_VERBOSE << "Unsupported graphic mode" << endl; + } + } + + // Unable to initialize mode + return false; +} + +bool Graphics::switchBuffers() { + if (!refresh) { + printer->buffer(buffer[scanout_buffer]); + scanout_buffer = 1 - scanout_buffer; + refresh = true; + return true; + } else { + return false; + } +} + +void Graphics::scanoutFrontbuffer() { + if (refresh) { + memcpy(address, buffer[scanout_buffer], size); + refresh = false; + } +} diff --git a/kernel/device/graphics.h b/kernel/device/graphics.h new file mode 100644 index 0000000..5b83362 --- /dev/null +++ b/kernel/device/graphics.h @@ -0,0 +1,284 @@ +/*! \file + * \brief The \ref Graphics device is an interface for the \ref Framebuffer + */ + +#pragma once + +/*! \defgroup gfx Graphics + * + * Graphical VESA video modes. + */ + +#include "../graphics/primitives.h" +#include "../graphics/printer.h" + +/*! \brief Driver managing the video mode and synchronizing its buffer with the + * \ref AbstractGraphicsPrinter "graphics printer" + * \ingroup gfx + * + * This device detects the current video mode set by the \ref Multiboot + * compliant boot loader and initializes a suitable \ref GraphicsPrinter. + * + * With the methods \ref Graphics::switchBuffers() (to exchange front- and + * backbuffer) and \ref Graphics::scanoutFrontbuffer() (copying the contents of + * the frontbuffer into the video memory) it provides some kind of manually + * [triple + * buffering](https://en.wikipedia.org/wiki/Multiple_buffering#Triple_buffering). + * + * A typical usage is to fully prepare the back buffer before switching it with + * the front buffer + * \code{.cpp} + * graphics.init(); + * while(true) { + * // Draw on back buffer + * // using the primitives provided by the driver + * + * graphics.switchBuffers(); + * } + * \endcode + * + * The method \ref Graphics::scanoutFrontbuffer() has to be executed either + * inside the loop (right after \ref Graphics::switchBuffers() in the example + * above) or at a predefined interval by employing the \ref LAPIC::Timer. + * + * \note The driver requires \ref Multiboot to initialize a video mode, which + * can be configured using the flags in `boot/multiboot/config.inc`. + */ +class Graphics { + /*! \brief Pointer to a \ref GraphicsPrinter supporting the current video + * mode + */ + AbstractGraphicsPrinter* printer; + + /*! \brief Pointer to the physical address of the video memory (linear frame + * buffer) + */ + void* address; + + /*! \brief Video memory size required for a full screen picture + */ + unsigned size; + + /*! \brief Size of the front (or back) buffer (which has to be at least \ref + * size) + */ + unsigned buffer_size; + + /*! \brief Pointer to the two buffers + * (used alternately as front and back buffers) + */ + void* const buffer[2]; + + /*! \brief Index of the current front buffer + */ + int scanout_buffer; + + /*! \brief Has the current front buffer already been drawn? + */ + bool refresh; + + public: + /// MULTIBOOT_VIDEO_WIDTH * MULTIBOOT_VIDEO_HEIGHT * + /// MULTIBOOT_VIDEO_BITDEPTH (in bits) + static constexpr size_t SCREEN_BUF_SIZE = + 1920UL * 1080UL * 32UL / sizeof(char); + + /*! \brief Constructor + */ + Graphics(); + + /*! \brief Initialize \ref GraphicsPrinter according to the current video + * mode + * + * \param force Do not check video attributes for the linear frame buffer + * (required on our test systems due to some strange VBE + * behaviour) + * \return 'true' if a suitable \ref GraphicsPrinter was found for the video + * mode + */ + bool init(bool force = false); + + /*! \brief Switch front and back buffer + * (only if front buffer was already copied to video memory) + * + * \return `true` if buffers have been switched, `false` if previous front + * buffer wasn't yet fully copied to video memory. + */ + bool switchBuffers(); + + /*! \brief Copy current front buffer to the video memory + */ + void scanoutFrontbuffer(); + + /*! \brief Clear all pixel of the current back buffer + * (set full screen to black) + */ + void clear() { printer->clear(); } + + /*! \brief Check if a \ref Point can be displayed at the current resolution + * + * \param p Coordinates to check + * \return 'true' if can be displayed + */ + bool valid(const Point& p) { return printer->valid(p); } + + /*! \brief Number of vertical pixels in current resolution + * + * \return Height of the screen in current video mode + */ + unsigned height() { return printer->height(); } + + /*! \brief Number of horizontal pixels in current resolution + * + * \return Width of the screen in current video mode + */ + unsigned width() { return printer->width(); } + + /*! \brief Draw a pixel on the current back buffer + * + * \param p Coordinates of the pixel + * \param color Color of the pixel + */ + void pixel(const Point& p, const Color& color) { printer->pixel(p, color); } + + /// \copydoc pixel + void pixel(const Point& p, const ColorAlpha& color) { + printer->pixel(p, color); + } + + /*! \brief Draw a line on the current back buffer + * + * \param start Coordinates of the begin of the line + * \param end Coordinates of the end of the line + * \param color Color of the line + */ + void line(const Point& start, const Point& end, const Color& color) { + printer->line(start, end, color); + } + + /// \copydoc line + void line(const Point& start, const Point& end, const ColorAlpha& color) { + printer->line(start, end, color); + } + + /*! \brief Draw a rectangle on the current back buffer + * + * \param start Coordinate of the rectangles upper left corner + * \param end Coordinate of the rectangles lower right corner + * \param color Color of the rectangle + * \param filled If set, the rectangle will be filled with the same color. + * (otherwise only borders will be drawn) + */ + void rectangle(const Point& start, const Point& end, const Color& color, + bool filled = true) { + printer->rectangle(start, end, color, filled); + } + + /// \copydoc rectangle + void rectangle(const Point& start, const Point& end, + const ColorAlpha& color, bool filled = true) { + printer->rectangle(start, end, color, filled); + } + + /*! \brief Change the current font for text output in video mode + * + * \param new_font Font to be used on subsequent calls to \ref text (without + * explicit font parameter) + */ + void font(const Font& new_font) { printer->font(new_font); } + + /*! \brief Print text (without automatic word wrap) on the current back + * buffer + * + * \param p Upper left start position of the text + * \param string Pointer to char array containing the text to be displayed + * \param len Number of characters to be displayed + * \param color Color for the text characters + * \param font Explicit font -- or `nullptr` to use default font (set by + * \ref font method) + */ + void text(const Point& p, const char* string, unsigned len, + const Color& color, const Font* font = nullptr) { + printer->text(p, string, len, color, font); + } + + /// \copydoc text + void text(const Point& p, const char* string, unsigned len, + const ColorAlpha& color, const Font* font = nullptr) { + printer->text(p, string, len, color, font); + } + + /*! \brief Draw a \ref PNG image [detail] on the current back buffer. + * + * The image can has to be in a supported \ref PNG format. + * Alpha blending (transparency) is supported. + * + * \param p Coordinate of the images upper left corner + * \param image Source image to display + * \param width Width of the image detail (full image width of the source + * image if zero/default value) + * \param height Height of the image detail (full image height of the source + * if zero/default value) + * \param offset_x Right offset of the source image + * \param offset_y Top offset of the source image + */ + void image(const Point& p, PNG& image, unsigned width = 0, + unsigned height = 0, unsigned offset_x = 0, + unsigned offset_y = 0) { + printer->image(p, image, width, height, offset_x, offset_y); + } + + /*! \brief Draw a GIMP image [detail] on the current back buffer. + * + * The image has to be exported as C-source (without `Glib` types!) in + * [GIMP](https://www.gimp.org/), alpha blending (transparency) is + * supported. + * + * \param p Coordinate of the images upper left corner + * \param image Source image to display + * \param width Width of the image detail (full image width of the source + * image if zero/default value) + * \param height Height of the image detail (full image height of the source + * if zero/default value) + * \param offset_x Right offset of the source image + * \param offset_y Top offset of the source image + */ + void image(const Point& p, const GIMP& image, unsigned width = 0, + unsigned height = 0, unsigned offset_x = 0, + unsigned offset_y = 0) { + printer->image(p, image, width, height, offset_x, offset_y); + } + + /*! \brief Draw a sprite on the current back buffer. + * + * Each element in the source array will be displayed as a single pixel. + * + * \param p Coordinate of the sprites upper left corner + * \param image Source sprite to display + * \param width Width of the sprite detail + * \param height Height of the sprite detail + * \param offset_x Right offset of the source sprite + * \param offset_y Top offset of the source sprite + */ + void image(const Point& p, const Color* image, unsigned width, + unsigned height, unsigned offset_x = 0, unsigned offset_y = 0) { + printer->image(p, image, width, height, offset_x, offset_y); + } + + /*! \brief Draw a sprite with alpha blending (transparency) on the current + * back buffer. + * + * Each element in the source array will be displayed as a single pixel. + * + * \param p Coordinate of the sprites upper left corner + * \param image Source sprite to display + * \param width Width of the sprite detail + * \param height Height of the sprite detail + * \param offset_x Right offset of the source sprite + * \param offset_y Top offset of the source sprite + */ + void image(const Point& p, const ColorAlpha* image, unsigned width, + unsigned height, unsigned offset_x = 0, unsigned offset_y = 0) { + printer->image(p, image, width, height, offset_x, offset_y); + } +}; diff --git a/kernel/device/graphicsstream.cc b/kernel/device/graphicsstream.cc new file mode 100644 index 0000000..eed939d --- /dev/null +++ b/kernel/device/graphicsstream.cc @@ -0,0 +1,131 @@ +#include "./graphicsstream.h" + +#include "../debug/assert.h" +#include "../graphics/fonts/font.h" +#include "../interrupt/guard.h" +#include "../utils/alloc.h" +#include "../utils/math.h" + +const Color GraphicsStream::BLACK(0x00, 0x00, 0x00); +const Color GraphicsStream::BLUE(0x00, 0x00, 0xAA); +const Color GraphicsStream::GREEN(0x00, 0xAA, 0x00); +const Color GraphicsStream::CYAN(0x00, 0xAA, 0xAA); +const Color GraphicsStream::RED(0xAA, 0x00, 0x00); +const Color GraphicsStream::MAGENTA(0xAA, 0x00, 0xAA); +const Color GraphicsStream::BROWN(0xAA, 0x55, 0x00); +const Color GraphicsStream::LIGHT_GREY(0xAA, 0xAA, 0xAA); + +const Color GraphicsStream::DARK_GREY(0x55, 0x55, 0x55); +const Color GraphicsStream::LIGHT_BLUE(0x55, 0x55, 0xFF); +const Color GraphicsStream::LIGHT_GREEN(0x55, 0xFF, 0x55); +const Color GraphicsStream::LIGHT_CYAN(0x55, 0xFF, 0xFF); +const Color GraphicsStream::LIGHT_RED(0xFF, 0x55, 0x55); +const Color GraphicsStream::LIGHT_MAGENTA(0xFF, 0x55, 0xFF); +const Color GraphicsStream::YELLOW(0xFF, 0xFF, 0x55); +const Color GraphicsStream::WHITE(0xFF, 0xFF, 0xFF); + +GraphicsStream::GraphicsStream(const Point &start, unsigned width, + unsigned height, Font *const font) + : offset(0), + x(0), + y(0), + FONT(font == nullptr ? Font::get() : font), + START(start), + ROWS(height / this->FONT->height), + COLUMNS(width / this->FONT->width) { + cell = reinterpret_cast(calloc(ROWS * COLUMNS, sizeof(Cell))); +} + +void GraphicsStream::setPos(int x, int y) { + if (x < 0) { + x += COLUMNS; + } + if (y < 0) { + y += ROWS; + } + + if (x >= 0 && static_cast(x) < COLUMNS && y >= 0 && + static_cast(y) <= ROWS) { + this->x = x; + this->y = y; + } +} + +void GraphicsStream::getPos(int &x, int &y) const { + x = this->x; + y = this->y; +} + +void GraphicsStream::show(int x, int y, char character, const Color &color) { + if (x < 0) { + x += COLUMNS; + } + if (y < 0) { + y += ROWS; + } + // only print if position within the screen range + if (x >= 0 && static_cast(x) < COLUMNS && y >= 0 && + static_cast(y) < ROWS) { + cell[((offset + y) % ROWS) * COLUMNS + x] = (Cell){character, color}; + } +} + +void GraphicsStream::print(char *str, int length, const Color &color) { + while (length > 0) { + switch (*str) { + case '\n': + for (unsigned i = x; i < COLUMNS; ++i) { + show(i, y, ' ', color); + } + x = 0; + y++; + break; + + default: + show(x, y, *str, color); + if (++x >= COLUMNS) { + x = 0; + y++; + } + break; + } + str++; + if (y >= ROWS) { + offset = (offset + 1) % ROWS; + y--; + for (unsigned i = 0; i < COLUMNS; ++i) { + show(i, y, ' ', color); + } + } + length--; + } +} + +void GraphicsStream::reset(char character, const Color &color) { + for (unsigned y = 0; y < ROWS; ++y) { + for (unsigned x = 0; x < COLUMNS; ++x) { + show(x, y, character, color); + } + } + setPos(0, 0); +} + +void GraphicsStream::flush() { + print(buffer, pos); + pos = 0; +} + +void GraphicsStream::draw() { + flush(); + Point pos = START; + for (unsigned y = 0; y < ROWS; y++) { + for (unsigned x = 0; x < COLUMNS; x++) { + Cell &c = cell[((offset + y) % ROWS) * COLUMNS + x]; + Guard::enter().vault().graphics.text(pos, &c.character, 1, c.color, + FONT); + pos.x += FONT->width; + } + pos.x = START.x; + pos.y += FONT->height; + } +} diff --git a/kernel/device/graphicsstream.h b/kernel/device/graphicsstream.h new file mode 100644 index 0000000..3c829a3 --- /dev/null +++ b/kernel/device/graphicsstream.h @@ -0,0 +1,135 @@ +/*! \file + * \brief \ref GraphicsStream, a \ref Graphics "graphical" \ref OutputStream + * "output stream" inspired by (and compatible to) \ref TextStream + */ + +#pragma once + +#include "../graphics/primitives.h" +#include "../object/outputstream.h" +#include "./graphics.h" + +/*! \brief Output text (form different data type sources) on screen in \ref + * Graphics "graphic mode" (similar to \ref TextStream) + * \ingroup gfx + * \ingroup io + * + * Enables output of different data types using a monospaced font on a + * predefined area of the screen with activated graphics mode. + */ +class GraphicsStream : public OutputStream { + // Prevent copies and assignments + GraphicsStream(const GraphicsStream&) = delete; + GraphicsStream& operator=(const GraphicsStream&) = delete; + + struct Cell { + char character; + Color color; + }; + + Cell* cell; + unsigned offset; + + unsigned x, y; ///< Cursor position + + protected: + /*! \brief Output the buffer contents of the base class \ref Stringbuffer + * + * The method is automatically called when the buffer is full, + * but can also be called explicitly to force output of the current buffer. + */ + void flush(); + + public: + Font* const FONT; ///< Default font + const Point START; ///< Upper left corner of the window + const unsigned ROWS; ///< Number of rows in the window + const unsigned COLUMNS; ///< Number of columns in the window + + /*! \brief CGA color palette + */ + static const Color BLACK, BLUE, GREEN, CYAN, RED, MAGENTA, BROWN, + LIGHT_GREY, DARK_GREY, LIGHT_BLUE, LIGHT_GREEN, LIGHT_CYAN, LIGHT_RED, + LIGHT_MAGENTA, YELLOW, WHITE; + + /*! \brief Constructor + * + * Creates a window (= area on the screen) for text output. + * Within the window text uses a virtual (invisible) cursor to offer a + * very similar behavior to \ref TextStream -- including automatic + * scrolling and column/row based positioning. + * + * \param start Coordinate of the upper left corner for the output window + * \param width Width of the output window + * \param height Height of the output window + * \param font Font used for output text (or `nullptr` for default font) + */ + GraphicsStream(const Point& start, unsigned width, unsigned height, + Font* font = nullptr); + + /*! \brief Set the cursor position + * + * \param x Column in window + * \param y Row in window + */ + void setPos(int x, int y); + + /*! \brief Read the current cursor position + * + * \param x Column in window + * \param y Row in window + */ + void getPos(int& x, int& y) const; + + /*! \brief Display multiple characters in the window starting at the current + * cursor position + * + * This method can be used to output a string, starting at the current + * cursor position. Since the string does not need to contain a '\0' + * termination (as it is usually the case in C), the parameter `length` is + * required to specify the number of characters in the string. When the + * output is complete, the cursor will be positioned after the last + * character printed. The entire text uniformly has the color `color` + * + * If there is not enough space left at the end of the line, the output will + * be continued on the following line. As soon as the last window line is + * filled, the entire window area will be moved up one line. + * The first line disappears and the last line is blank, continuing output + * there. + * + * A line break will also occurs wherever the character `\\n` is inserted + * in the text to be output. + * + * \param str String to output + * \param length length of string + * \param color Foreground color of string + */ + void print(char* str, int length, const Color& color = LIGHT_GREY); + + /*! \brief Clear window and reset cursor + * + * \param character Filling character + * \param color Foreground color + */ + void reset(char character = ' ', const Color& color = LIGHT_GREY); + + /*! \brief Basic output of a (colored) character at a certain position on + * the screen. + * + * Outputs `character` at the absolute position (`x`, `y`) with the + * specified color: `x` specifies the column and `y` the row of the desired + * position, with 0 ≤ x < \ref COLUMNS and 0 ≤ `y` < \ref ROWS. + * The position (0,0) indicates the upper left corner of the window (at + * the coordinates \ref START). + * + * \param x Column for output of the character + * \param y Row for output of the character + * \param character Character to be output + * \param color Foreground color + */ + void show(int x, int y, char character, const Color& color = LIGHT_GREY); + + /*! \brief Draw using the \ref Graphics device + */ + void draw(); +}; diff --git a/kernel/device/keydecoder.cc b/kernel/device/keydecoder.cc new file mode 100644 index 0000000..cf93996 --- /dev/null +++ b/kernel/device/keydecoder.cc @@ -0,0 +1,131 @@ +#include "keydecoder.h" + +#include "ps2controller.h" + +// Constants used for key decoding +constexpr unsigned char BREAK_BIT = 0x80; +constexpr unsigned char PREFIX_1 = 0xe0; +constexpr unsigned char PREFIX_2 = 0xe1; + +Key KeyDecoder::decode(unsigned char code) { + Key key = modifier; + + // All keys that are introduced by the MF II keyboard (compared to the older + // AT keyboard) always send a prefix value as first byte. + if (code == PREFIX_1 || code == PREFIX_2) { + prefix = code; + } else { + // Releasing a key is, for us, only important for the modifier keys such + // as SHIFT, CTRL and ALT, For other, non-modifier keys, we ignore the + // break code. + bool pressed = (code & BREAK_BIT) == 0; + + // A key's break code is identical to its make code with an additionally + // set BREAK_BIT + Key::Scancode scancode = + static_cast(code & (~BREAK_BIT)); + + // We ignore "new" special keys, such as the Windows key + if (scancode < Key::Scancode::KEYS) { + // save state + status[static_cast(scancode)] = pressed; + + // Take a closer look at modifier make and break events + bool isModifier = true; + switch (scancode) { + // both shifts are handled equally + case Key::Scancode::KEY_LEFT_SHIFT: + case Key::Scancode::KEY_RIGHT_SHIFT: + modifier.shift = pressed; + break; + + case Key::Scancode::KEY_LEFT_ALT: + if (prefix == PREFIX_1) { + modifier.alt_right = pressed; + } else { + modifier.alt_left = pressed; + } + break; + + case Key::Scancode::KEY_LEFT_CTRL: + if (prefix == PREFIX_1) { + modifier.ctrl_right = pressed; + } else { + modifier.ctrl_left = pressed; + } + break; + + default: + isModifier = false; + } + + // For keys other than modifiers, we only care about the make code + if (pressed && !isModifier) { + switch (scancode) { + case Key::Scancode::KEY_CAPS_LOCK: + modifier.caps_lock ^= 1; + setLed(PS2Controller::LED_CAPS_LOCK, + modifier.caps_lock); + break; + + case Key::Scancode::KEY_SCROLL_LOCK: + modifier.scroll_lock ^= 1; + setLed(PS2Controller::LED_SCROLL_LOCK, + modifier.scroll_lock); + break; + + case Key::Scancode::KEY_NUM_LOCK: // Can be both NumLock + // and pause + // On old keyboards, the pause functionality was only + // accessible by pressing Ctrl+NumLock. Modern MF-II + // keyboards therefore send exactly this code + // combination when the pause key was pressed. Normally, + // the pause key does not provide an ASCII code, but we + // check that anyway. In either case, we're now done + // decoding. + if (modifier.ctrl_left) { // pause key + key.scancode = scancode; + } else { // NumLock + modifier.num_lock ^= 1; + setLed(PS2Controller::LED_NUM_LOCK, + modifier.num_lock); + } + break; + + // Special case scan code 53: This code is used by both the + // minus key on the main keyboard and the division key on + // the number block. When the division key was pressed, we + // adjust the scancode accordingly. + case Key::Scancode::KEY_SLASH: + if (prefix == PREFIX_1) { + key.scancode = Key::Scancode::KEY_DIV; + key.shift = true; + } else { + key.scancode = scancode; + } + break; + + default: + key.scancode = scancode; + + // When NumLock is enabled and a key on the keypad was + // pressed, we want return the ASCII and scan codes of + // the corresponding numerical key instead of the arrow + // keys. The keys on the cursor block (prefix == + // PREFIX_1), however, should remain usable. Therefore, + // as a little hack, we deactivate the NumLock for these + // keys. + if (modifier.num_lock && prefix == PREFIX_1) { + key.num_lock = false; + } + } + } + } + + // The prefix is only valid for the immediately following code, which + // was just handled. + prefix = 0; + } + + return key; +} diff --git a/kernel/device/keydecoder.h b/kernel/device/keydecoder.h new file mode 100644 index 0000000..b0c3848 --- /dev/null +++ b/kernel/device/keydecoder.h @@ -0,0 +1,40 @@ +/*! \file + * \brief \ref KeyDecoder decodes a keystroke to the corresponding \ref Key + * object + */ + +#pragma once +#include "../object/key.h" +#include "../types.h" + +/*! \brief Decoder for \ref ps2keyboardset1 "keyboard codes" received from the + * \ref PS2Controller + * \ingroup io + * + * Extracts the make and break codes, modifier and scan codes from the pressed + * key. + */ +class KeyDecoder { + unsigned char prefix; ///< Prefix byte for keys + Key modifier; ///< activated modifier keys (e.g., caps lock) + + public: + /*! \brief Current state (pressed or released) of all keys. + */ + bool status[static_cast(Key::Scancode::KEYS)]; + + /*! \brief Default constructor + */ + KeyDecoder() {} + + /*! \brief Interprets the \ref ps2keyboardset1 "make and break codes" + * received from the keyboard and derives the corresponding scan code and + * further information about other pressed keys, such as \key{shift} and + * \key{ctrl}. + * + * \param code Byte from Keyboard to decode + * \return Pressed key (\ref Key::valid returns `false` if the key is not + * yet complete) + */ + Key decode(unsigned char code); +}; diff --git a/kernel/device/ps2controller.cc b/kernel/device/ps2controller.cc new file mode 100644 index 0000000..03a9d8d --- /dev/null +++ b/kernel/device/ps2controller.cc @@ -0,0 +1,169 @@ +#include "ps2controller.h" + +#include "../arch/apic.h" +#include "../arch/core_interrupt.h" +#include "../arch/ioapic.h" +#include "../arch/ioport.h" +#include "keydecoder.h" + +namespace PS2Controller { + +// I/O Ports of the PS2 Controller +/// Access status- (read) and command (write) register +static const IOPort ctrl_port(0x64); +/// Access PS/2 device [keyboard] output- (read) and input (write) buffer +static const IOPort data_port(0x60); +/* The buffers are used to communicate with the controller or the connected + * PS/2 devices alike: + * - For the output buffer, the controller decides to which PS/2 device the + * data gets forwarded to -- by default it is the primary PS/2 device + * (keyboard). + * - The source device from which the data was gathered can be determined using + * the status flag (\ref IS_MOUSE). + * + * Please also note, that the naming of the buffer may be a bit contra-intuitive + * since it is the perspective of the PS/2 controller due to historical reasons. + */ + +// Key decoder (stores the state of the modifier keys) +static KeyDecoder key_decoder; + +// To store the current state of the Keyboard LEDs +static uint8_t leds = 0; + +/*! \brief Flags in the PS/2 controller status register + */ +enum Status { + HAS_OUTPUT = 1 << 0, ///< Output buffer non-empty? + INPUT_PENDING = 1 << 1, ///< Is input buffer full? + SYSTEM_FLAG = 1 << 2, ///< set on soft reset, cleared on power up + IS_COMMAND = 1 << 3, ///< Is command Byte? (otherwise data) + IS_MOUSE = 1 << 5, ///< Mouse output has data + TIMEOUT_ERROR = 1 << 6, ///< Timeout error + PARITY_ERROR = 1 << 7 ///< Parity error +}; + +/*! \brief Commands to be send to the Keyboard + */ +enum KeyboardCommand : uint8_t { + KEYBOARD_SET_LED = + 0xed, ///< Set the LED (according to the following parameter byte) + KEYBOARD_SEND_ECHO = 0xee, ///< Send an echo packet + KEYBOARD_SET_SPEED = 0xf3, ///< Set the repeat rate (according to the + ///< following parameter byte) + KEYBOARD_ENABLE = 0xf4, ///< Enable Keyboard + KEYBOARD_DISABLE = 0xf5, ///< Disable Keyboard + KEYBOARD_SET_DEFAULT = 0xf6, ///< Load defaults +}; + +/*! \brief Replies + */ +enum Reply { + ACK = 0xfa, ///< Acknowledgement + RESEND = 0xfe, ///< Request to resend (not required to implement) + ECHO = 0xee ///< Echo answer +}; + +/*! \brief Commands for the PS/2 Controller + * + * These commands are processed by the controller and *not* send to + * keyboard/mouse. They have to be written into the command register. + */ +enum ControllerCommand { + CONTROLLER_GET_COMMAND_BYTE = + 0x20, ///< Read Command Byte of PS/2 Controller + CONTROLLER_SET_COMMAND_BYTE = + 0x60, ///< Write Command Byte of PS/2 Controller + CONTROLLER_MOUSE_DISABLE = 0xa7, ///< Disable mouse interface + CONTROLLER_MOUSE_ENABLE = 0xa8, ///< Enable mouse interface + CONTROLLER_KEYBOARD_DISABLE = 0xad, ///< Disable keyboard interface + CONTROLLER_KEYBOARD_ENABLE = 0xae, ///< Enable keyboard interface + CONTROLLER_SEND_TO_MOUSE = 0xd4, ///< Send parameter to mouse device +}; + +/*! \brief Send a command or data to a connected PS/2 device + * + * The value must only be written into the input buffer after the previously + * written values have been fetched (\ref INPUT_PENDING in the status register). + * + * + * \param value data to be sent + */ +[[maybe_unused]] static void sendData(uint8_t value) { + // First of all, we have to wait for the controller to fetch all the + // characters we have written so far. + while ((ctrl_port.inb() & INPUT_PENDING) != 0) { + } // wait for keyboard inbuffer + + // Send the data byte, which gets acked (each) by the keyboard + data_port.outb(value); +} + +void init() { + // Switch all LEDs off (on many PCs NumLock is turned on after power up) + setLed(LED_CAPS_LOCK, false); + setLed(LED_SCROLL_LOCK, false); + setLed(LED_NUM_LOCK, false); + + // Set to maximum speed & minimum delay + setRepeatRate(SPEED_30_0CPS, DELAY_250MS); + + IOAPIC::config(APIC::getIOAPICSlot(APIC::Device::KEYBOARD), + Core::Interrupt::Vector::KEYBOARD, + IOAPIC::TriggerMode::LEVEL); + IOAPIC::allow(APIC::getIOAPICSlot(APIC::Device::KEYBOARD)); + drainBuffer(); +} + +bool fetch(Key& pressed) { + int control = ctrl_port.inb(); + if ((control & HAS_OUTPUT) != 0) { + // Get data + uint8_t code = data_port.inb(); + // Ignore mouse + if ((control & IS_MOUSE) == 0) { + // Decode key + pressed = key_decoder.decode(code); + // Return if valid + if (pressed.valid()) { + return true; + } + } + } + return false; +} + +void setRepeatRate(Speed speed, Delay delay) { + // Implementation was hidden behind the `keyboard_out` tag + union { + struct { + Speed speed : 5; + Delay delay : 2; + uint8_t : 1; + } __attribute__((packed)); + uint8_t value; + } rate; + rate.speed = speed; + rate.delay = delay; + + sendData(KEYBOARD_SET_SPEED); // Command for the Keyboard + sendData(rate.value); // Parameter +} + +void setLed(enum LED led, bool on) { + if (on) { + leds |= led; + } else { + leds &= ~led; + } + sendData(KEYBOARD_SET_LED); // Command for the Keyboard + sendData(leds); // Parameter +} + +void drainBuffer() { + while ((ctrl_port.inb() & HAS_OUTPUT) != 0) { + data_port.inb(); + } +} + +} // namespace PS2Controller diff --git a/kernel/device/ps2controller.h b/kernel/device/ps2controller.h new file mode 100644 index 0000000..0f95e6d --- /dev/null +++ b/kernel/device/ps2controller.h @@ -0,0 +1,150 @@ +/*! \file + * \brief \ref PS2Controller "PS/2 Controller" (Intel 8042, also known as + * Keyboard Controller) + */ + +#pragma once +#include "../object/key.h" +#include "../types.h" +#include "./textstream.h" + +/*! \brief PS/2 Controller + * \ingroup io + * + * Initializes the PS/2 devices (Keyboard and optional Mouse), and + * determines both the scan code and ASCII character of a pressed key from the + * transmitted make and break codes using the \ref KeyDecoder. + * + * \note This controller is also known as Intel 8042 (nowadays integrated in + * the mainboard) or *Keyboard Controller*. + * But to avoid confusion with the actual Keyboard and since we use the + * PS/2-compatible mode to support the Mouse as well, the name + * PS/2 Controller was chosen for the sake of simplicity. + * + * \note Since modern PCs sometimes don't have an PS/2 connector, USB keyboards + * and mice are emulated as PS/2 device with USB Legacy Support. + */ +namespace PS2Controller { +/*! \brief Initialization of connected devices + * + * All status LEDs of the keyboard are switched off and the repetition rate is + * set to maximum speed. + * + * Later the \ref IOAPIC is configured to receive corresponding interrupts. + * + * \note The keyboard interrupts should be configured as \ref IOAPIC::LEVEL + * "level triggered". According to the standard we would have to check the + * corresponding entry in + * \ref ACPI::MADS::Interrupt_Source_Override and use these values. Most + * likely this would suggest an \ref IOAPIC::EDGE "edge-triggered mode" -- which + * would work as well. However, using a \ref IOAPIC::LEVEL "level-triggered + * mode" is more forgiving because it resends the interrupt request even if an + * interrupt was lost (e.g. the required handling, retrieving the buffer entry, + * was not performed). + * + */ +void init(); + +/*! \brief Retrieve the keyboard event + * + * Retrieves make and brake events from the keyboard. + * If a valid (non special) key was pressed, the scan code is determined + * using \ref KeyDecoder::decode into a \ref Key object. + * Events on special keys like \key{Shift}, \key{Alt}, \key{CapsLock} etc. are + * stored (in \ref KeyDecoder) and applied on subsequent keystrokes, while no + * valid key is retrieved. + * + * Mouse events are ignored. + * + * + * + * \param pressed Reference to an object which will contain the pressed \ref Key + * on success + * \return `true` if a valid key was decoded + */ +bool fetch(Key& pressed); + +/*! \brief Delay before the keyboard starts repeating sending a pressed key + */ +enum Delay { + DELAY_250MS = 0, ///< Delay of 0.25s + DELAY_500MS = 1, ///< Delay of 0.5s + DELAY_750MS = 2, ///< Delay of 0.75s + DELAY_1000MS = 3 ///< Delay of 1s +}; + +/*! \brief Repeat Rate of Characters + * + * \see \ref ps2keyboard + */ +enum Speed { + SPEED_30_0CPS = 0x00, ///< 30 characters per second + SPEED_26_7CPS = 0x01, ///< 26.7 characters per second + SPEED_24_0CPS = 0x02, ///< 24 characters per second + SPEED_21_8CPS = 0x03, ///< 12.8 characters per second + SPEED_20_7CPS = 0x04, ///< 20.7 characters per second + SPEED_18_5CPS = 0x05, ///< 18.5 characters per second + SPEED_17_1CPS = 0x06, ///< 17.1 characters per second + SPEED_16_0CPS = 0x07, ///< 16 characters per second + SPEED_15_0CPS = 0x08, ///< 15 characters per second + SPEED_13_3CPS = 0x09, ///< 13.3 characters per second + SPEED_12_0CPS = 0x0a, ///< 12 characters per second + SPEED_10_9CPS = 0x0b, ///< 10.9 characters per second + SPEED_10_0CPS = 0x0c, ///< 10 characters per second + SPEED_09_2CPS = 0x0d, ///< 9.2 characters per second + SPEED_08_6CPS = 0x0e, ///< 8.6 characters per second + SPEED_08_0CPS = 0x0f, ///< 8 characters per second + SPEED_07_5CPS = 0x10, ///< 7.5 characters per second + SPEED_06_7CPS = 0x11, ///< 6.7 characters per second + SPEED_06_0CPS = 0x12, ///< 6 characters per second + SPEED_05_5CPS = 0x13, ///< 5.5 characters per second + SPEED_05_0CPS = 0x14, ///< 5 characters per second + SPEED_04_6CPS = 0x15, ///< 4.6 characters per second + SPEED_04_3CPS = 0x16, ///< 4.3 characters per second + SPEED_04_0CPS = 0x17, ///< 4 characters per second + SPEED_03_7CPS = 0x18, ///< 3.7 characters per second + SPEED_03_3CPS = 0x19, ///< 3.3 characters per second + SPEED_03_0CPS = 0x1a, ///< 3 characters per second + SPEED_02_7CPS = 0x1b, ///< 2.7 characters per second + SPEED_02_5CPS = 0x1c, ///< 2.5 characters per second + SPEED_02_3CPS = 0x1d, ///< 2.3 characters per second + SPEED_02_1CPS = 0x1e, ///< 2.1 characters per second + SPEED_02_0CPS = 0x1f, ///< 2 characters per second +}; + +/*! \brief Configure the repeat rate of the keyboard + * + * \param delay configures how long a key must be pressed before the repetition + * begins. + * \param speed determines how fast the key codes should follow each other. + * Valid values are between `0` (30 characters per second) and + * `31` (2 characters per second). + */ +void setRepeatRate(Speed speed, Delay delay); + +/*! \brief Keyboard LEDs + */ +enum LED { + LED_SCROLL_LOCK = 1 << 0, ///< Scroll Lock + LED_NUM_LOCK = 1 << 1, ///< Num Lock + LED_CAPS_LOCK = 1 << 2, ///< Caps Lock +}; + +/*! \brief Enable or disable a keyboard LED + * + * \param led LED to enable or disable + * \param on `true` will enable the specified LED, `false` disable + */ +void setLed(enum LED led, bool on); + +/*! \brief Empties the keyboard buffer. + * + * The keyboard may not send any interrupts if the buffer is not empty. + * To prevent unhandled keystrokes (for example during boot) the buffer + * should be emptied once right before allowing keyboard interrupts + * (even if keystrokes might be lost). + * + */ +void drainBuffer(); + +} // namespace PS2Controller diff --git a/kernel/device/serialstream.cc b/kernel/device/serialstream.cc new file mode 100644 index 0000000..bb9e4ee --- /dev/null +++ b/kernel/device/serialstream.cc @@ -0,0 +1,37 @@ +#include "serialstream.h" + +SerialStream::SerialStream(ComPort port, BaudRate baud_rate, DataBits data_bits, + StopBits stop_bits, Parity parity) + : Serial(port, baud_rate, data_bits, stop_bits, parity) {} + +void SerialStream::flush() { + print(buffer, pos); + pos = 0; +} + +void SerialStream::setForeground(Color c) { + *this << "\e[" << (30 + static_cast(c)) << 'm'; +} + +void SerialStream::setBackground(Color c) { + *this << "\e[" << (40 + static_cast(c)) << 'm'; +} + +void SerialStream::setAttribute(Attrib a) { + *this << "\e[" << static_cast(a) << 'm'; +} + +void SerialStream::reset() { *this << "\ec" << ::flush; } + +void SerialStream::setPos(int x, int y) { + *this << "\e[" << (y + 1) << ';' << (x + 1) << 'H' << ::flush; +} + +void SerialStream::print(char* str, int length) { + for (int p = 0; p < length; p++) { + if (str[p] == '\n' && (p == 0 || str[p - 1] != '\r')) { + write('\r'); + } + write(str[p]); + } +} diff --git a/kernel/device/serialstream.h b/kernel/device/serialstream.h new file mode 100644 index 0000000..59f4be0 --- /dev/null +++ b/kernel/device/serialstream.h @@ -0,0 +1,138 @@ +/*! \file + * \brief \ref Serial \ref SerialStream "output stream" + */ + +#pragma once +#include "../arch/serial.h" +#include "../object/outputstream.h" +#include "../types.h" + +/*! \brief Console (VT100 compatible) via \ref Serial interface. + * \ingroup io + * + * This class allows to connect a VT100-compatible display terminal via + * the serial interface. + * + * The utility 'screen' can be used to attach a terminal to an interface + * at a specified connection speed: `screen /dev/ttyS0 115200` + * + * Color and position can be adjusted with the help of + * [escape + * codes](http://web.archive.org/web/20181008150037/http://www.termsys.demon.co.uk/vtansi.htm). + */ + +class SerialStream : public OutputStream, public Serial { + public: + /*! \brief Attributes + * can be used to influence the display of the output. + * + * \note The attributes might not be supported or have a different effect + * depending on the terminal emulator! + */ + enum class Attrib : uint32_t { + RESET = 0, ///< Turn off character attributes + BRIGHT = 1, ///< Bold + DIM = 2, ///< Low intensity (dimmed) + ITALIC = 3, ///< Italic + UNDERSCORE = 4, ///< Underline + BLINK = 5, ///< Blink (slow) + REVERSE = 7, ///< Swap fore & background + HIDDEN = 8, ///< Concealed + }; + + /*! \brief Color codes + * + * Default VT100 supports eight colors for both foreground and background + * (later versions 256 [8 bit] and even true color [32 bit]). + * The actual color is affected by the attributes and can look significantly + * different depending on the terminal emulator. + */ + enum class Color : uint32_t { + BLACK = 0, + RED = 1, + GREEN = 2, + YELLOW = 3, + BLUE = 4, + MAGENTA = 5, + CYAN = 6, + WHITE = 7 + }; + + /*! \brief Constructor for the VT100-compatible console + * + * Sets up the serial connection as well + * + */ + explicit SerialStream(ComPort port = Serial::ComPort::COM1, + BaudRate baud_rate = Serial::BaudRate::B115200, + DataBits data_bits = Serial::DataBits::D8, + StopBits stop_bits = Serial::StopBits::S1, + Parity parity = Serial::Parity::NONE); + + /*! \brief Method to output the buffer contents of the base class \ref + * Stringbuffer + * + * The method is automatically called when the buffer is full, + * but can also be called explicitly to force output of the current buffer. + * + */ + void flush() override; + + /*! \brief Change foreground color (for subsequent output) + * + * + * \param c Color + */ + void setForeground(Color c); + + /*! \brief Change background color (for subsequent output) + * + * + * \param c Color + */ + void setBackground(Color c); + + /*! \brief Change text attribute (for subsequent output) + * + * + * \param a Attribute + */ + void setAttribute(Attrib a); + + /*! \brief Reset terminal + * + * Clear screen, place cursor at the beginning and reset colors + * and attributes to the default value. + * + */ + void reset(); + + /*! \brief Set the cursor position + * + * \param x Column in window + * \param y Row in window + * + */ + void setPos(int x, int y); + + /*! \brief Display multiple characters in the window starting at the current + * cursor position + * + * This method can be used to output a string, starting at the current + * cursor position. Since the string does not need to contain a '\0' + * termination (as it is usually the case in C), the parameter `length` is + * required to specify the number of characters in the string. + * + * The text is displayed using the previously configured + * \ref setAttribute() "attributes", \ref setForeground() "fore-" + * and \ref setBackground "background" color. + * + * A line break will occur wherever the character `\n` is inserted + * in the text to be output (for compatibility reasons a `\r` is + * automatically appended). + * + * \param str String to output + * \param length length of string + */ + void print(char* str, int length); +}; diff --git a/kernel/device/textstream.cc b/kernel/device/textstream.cc new file mode 100644 index 0000000..4f3f7ca --- /dev/null +++ b/kernel/device/textstream.cc @@ -0,0 +1,10 @@ +#include "textstream.h" + +TextStream::TextStream(unsigned from_col, unsigned to_col, unsigned from_row, + unsigned to_row, bool use_cursor) + : TextWindow(from_col, to_col, from_row, to_row, use_cursor) {} + +void TextStream::flush() { + print(buffer, pos); + pos = 0; +} diff --git a/kernel/device/textstream.h b/kernel/device/textstream.h new file mode 100644 index 0000000..b01dee7 --- /dev/null +++ b/kernel/device/textstream.h @@ -0,0 +1,45 @@ +/*! \file + * \brief \ref TextStream outputs text onto the screen in \ref CGA + */ + +/*! \defgroup io I/O subsystem + * \brief The input/output subsystem + */ + +#pragma once +#include "../arch/textwindow.h" +#include "../object/outputstream.h" +#include "../types.h" + +/*! \brief Output text (form different data type sources) on screen in text + * mode + * \ingroup io + * + * Allows the output of different data types as strings on the \ref CGA + * screen of a PC. + * To achieve this, \ref TextStream is derived from both \ref OutputStream and + * \ref TextWindow and only implements the method \ref TextStream::flush(). + * Further formatting or special effects are implemented in \ref TextWindow. + */ +class TextStream : public OutputStream, public TextWindow { + // Prevent copies and assignments + TextStream(const TextStream&) = delete; + TextStream& operator=(const TextStream&) = delete; + + public: + /// \copydoc + /// TextWindow::TextWindow(unsigned,unsigned,unsigned,unsigned,bool) + TextStream(unsigned from_col, unsigned to_col, unsigned from_row, + unsigned to_row, bool use_cursor = false); + + /*! \brief Output the buffer contents of the base class \ref Stringbuffer + * + * The method is automatically called when the buffer is full, + * but can also be called explicitly to force output of the current buffer. + * + * + */ + // NOTE: We can only add the `override` once we inherit from `TextWindow` + // which is part of the solution. + void flush() override; +}; diff --git a/kernel/graphics/fonts/CPPLINT.cfg b/kernel/graphics/fonts/CPPLINT.cfg new file mode 100644 index 0000000..d3c1fb2 --- /dev/null +++ b/kernel/graphics/fonts/CPPLINT.cfg @@ -0,0 +1 @@ +exclude_files=font_.*\.h diff --git a/kernel/graphics/fonts/font.cc b/kernel/graphics/fonts/font.cc new file mode 100644 index 0000000..3190377 --- /dev/null +++ b/kernel/graphics/fonts/font.cc @@ -0,0 +1,44 @@ +#include "font.h" + +#include "../../types.h" +#include "../../utils/size.h" +#include "../../utils/string.h" +#include "font_10x18.h" +#include "font_6x10.h" +#include "font_6x11.h" +#include "font_7x14.h" +#include "font_8x16.h" +#include "font_8x8.h" +#include "font_acorn_8x8.h" +#include "font_mini_4x6.h" +#include "font_pearl_8x8.h" +#include "font_sun_12x22.h" +#include "font_sun_8x16.h" +#include "font_ter_16x32.h" + +static Font fonts[] = { + Font("Standard", 6, 10, fontdata_6x10), + Font("Standard", 7, 14, fontdata_7x14), + Font("Standard", 8, 8, fontdata_8x8), + Font("Standard", 8, 16, fontdata_8x16), + Font("Standard", 10, 18, fontdata_10x18), + Font("Acorn", 8, 8, acorndata_8x8), + Font("Mini", 4, 6, fontdata_mini_4x6), + Font("Pearl", 8, 8, fontdata_pearl_8x8), + Font("Sun", 12, 22, fontdata_sun_12x22), + Font("Sun", 8, 16, fontdata_sun_8x16), + Font("Terminus", 16, 32, fontdata_ter16x32), +}; + +unsigned Font::number() { return ::size(fonts); } + +Font* Font::get(const char* name, const unsigned width, const unsigned height) { + for (unsigned i = 0; i < number(); i++) { + if ((name == nullptr || strcmp(name, fonts[i].name) == 0) && + (width == 0 || width == fonts[i].width) && + (height == 0 || height == fonts[i].height)) { + return &fonts[i]; + } + } + return nullptr; +} diff --git a/kernel/graphics/fonts/font.h b/kernel/graphics/fonts/font.h new file mode 100644 index 0000000..59a1186 --- /dev/null +++ b/kernel/graphics/fonts/font.h @@ -0,0 +1,73 @@ +/*! \file + * \brief \ref Font "Monospaced fonts" + */ + +#pragma once + +#include "../../types.h" + +/*! \brief Monospaced fonts + * \ingroup gfx + * + * Console fonts are extracted from the Linux kernel + * ([/lib/fonts/](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/lib/fonts)). + */ +class Font { + /*! \brief Pointer to bitmap font + */ + const unsigned char* data; + + /*! \brief Size in memory of bitmap font + */ + const size_t size; + + public: + /*! \brief Name of font + */ + const char* name; + + /*! \brief Width of a character + */ + const unsigned width; + + /*! \brief Height of a character + */ + const unsigned height; + + /*! \brief Constructor for a font + * + * \param name Name of font + * \param width character width + * \param height character height + * \param data Pointer to bitmap font + */ + Font(const char* name, unsigned width, unsigned height, + const unsigned char* data) + : data(data), + size((((width + (8 >> 1)) / 8) * height)), + name(name), + width(width), + height(height) {} + + /*! \brief Get bitmap address for a given character + * + * \param c character (ASCII) + * \return Pointer to bitmap of character + */ + const void* symbol(unsigned char c) const { return &data[size * c]; } + + /*! \brief Find font + * + * \param name Name of font (or `nullptr` for any) + * \param width Width of a character (or `0` for any) + * \param height Height of a character (or `0` for any) + * \return Pointer to font or `nullptr` if no matching font was found + */ + static Font* get(const char* name = nullptr, unsigned width = 0, + unsigned height = 0); + + /*! \brief Get the number of available fonts + * \return number of fonts + */ + static unsigned number(); +}; diff --git a/kernel/graphics/fonts/font_10x18.h b/kernel/graphics/fonts/font_10x18.h new file mode 100644 index 0000000..d7f8d2e --- /dev/null +++ b/kernel/graphics/fonts/font_10x18.h @@ -0,0 +1,5130 @@ + +// SPDX-License-Identifier: GPL-2.0 +/******************************** + * adapted from font_sun12x22.c * + * by Jurriaan Kalkman 06-2005 * + ********************************/ + +static const unsigned char fontdata_10x18[] = { + + /* 0 0x00 '^@' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 1 0x01 '^A' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3f, 0x80, /* 0011111110 */ + 0x40, 0x40, /* 0100000001 */ + 0x5b, 0x40, /* 0101101101 */ + 0x40, 0x40, /* 0100000001 */ + 0x44, 0x40, /* 0100010001 */ + 0x44, 0x40, /* 0100010001 */ + 0x51, 0x40, /* 0101000101 */ + 0x4e, 0x40, /* 0100111001 */ + 0x40, 0x40, /* 0100000001 */ + 0x3f, 0x80, /* 0011111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 2 0x02 '^B' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3f, 0x80, /* 0011111110 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x64, 0xc0, /* 0110010011 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x7b, 0xc0, /* 0111101111 */ + 0x7b, 0xc0, /* 0111101111 */ + 0x6e, 0xc0, /* 0110111011 */ + 0x71, 0xc0, /* 0111000111 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x3f, 0x80, /* 0011111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 3 0x03 '^C' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x11, 0x00, /* 0001000100 */ + 0x3b, 0x80, /* 0011101110 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x3f, 0x80, /* 0011111110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x04, 0x00, /* 0000010000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 4 0x04 '^D' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x3f, 0x80, /* 0011111110 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x04, 0x00, /* 0000010000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 5 0x05 '^E' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x31, 0x80, /* 0011000110 */ + 0x7b, 0xc0, /* 0111101111 */ + 0x35, 0x80, /* 0011010110 */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 6 0x06 '^F' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x3f, 0x80, /* 0011111110 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x35, 0x80, /* 0011010110 */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 7 0x07 '^G' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 8 0x08 '^H' */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xf3, 0xc0, /* 1111001111 */ + 0xe1, 0xc0, /* 1110000111 */ + 0xe1, 0xc0, /* 1110000111 */ + 0xc0, 0xc0, /* 1100000011 */ + 0xc0, 0xc0, /* 1100000011 */ + 0xe1, 0xc0, /* 1110000111 */ + 0xe1, 0xc0, /* 1110000111 */ + 0xf3, 0xc0, /* 1111001111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + + /* 9 0x09 '^I' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x12, 0x00, /* 0001001000 */ + 0x12, 0x00, /* 0001001000 */ + 0x21, 0x00, /* 0010000100 */ + 0x21, 0x00, /* 0010000100 */ + 0x12, 0x00, /* 0001001000 */ + 0x12, 0x00, /* 0001001000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 10 0x0a '^J' */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xf3, 0xc0, /* 1111001111 */ + 0xed, 0xc0, /* 1110110111 */ + 0xed, 0xc0, /* 1110110111 */ + 0xde, 0xc0, /* 1101111011 */ + 0xde, 0xc0, /* 1101111011 */ + 0xed, 0xc0, /* 1110110111 */ + 0xed, 0xc0, /* 1110110111 */ + 0xf3, 0xc0, /* 1111001111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + + /* 11 0x0b '^K' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x03, 0xc0, /* 0000001111 */ + 0x06, 0xc0, /* 0000011011 */ + 0x0c, 0xc0, /* 0000110011 */ + 0x3c, 0x00, /* 0011110000 */ + 0x66, 0x00, /* 0110011000 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc3, 0x00, /* 1100001100 */ + 0x66, 0x00, /* 0110011000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 12 0x0c '^L' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x33, 0x00, /* 0011001100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 13 0x0d '^M' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0f, 0x80, /* 0000111110 */ + 0x08, 0x80, /* 0000100010 */ + 0x0f, 0x80, /* 0000111110 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x38, 0x00, /* 0011100000 */ + 0x78, 0x00, /* 0111100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 14 0x0e '^N' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x80, /* 0001111110 */ + 0x10, 0x80, /* 0001000010 */ + 0x1f, 0x80, /* 0001111110 */ + 0x10, 0x80, /* 0001000010 */ + 0x10, 0x80, /* 0001000010 */ + 0x10, 0x80, /* 0001000010 */ + 0x10, 0x80, /* 0001000010 */ + 0x13, 0x80, /* 0001001110 */ + 0x17, 0x80, /* 0001011110 */ + 0x73, 0x00, /* 0111001100 */ + 0xf0, 0x00, /* 1111000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 15 0x0f '^O' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x04, 0x00, /* 0000010000 */ + 0x24, 0x80, /* 0010010010 */ + 0x15, 0x00, /* 0001010100 */ + 0x55, 0x40, /* 0101010101 */ + 0x3f, 0x80, /* 0011111110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x3f, 0x80, /* 0011111110 */ + 0x55, 0x40, /* 0101010101 */ + 0x15, 0x00, /* 0001010100 */ + 0x24, 0x80, /* 0010010010 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 16 0x10 '^P' */ + 0x00, 0x80, /* 0000000010 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x80, /* 0000001110 */ + 0x07, 0x80, /* 0000011110 */ + 0x0f, 0x80, /* 0000111110 */ + 0x1f, 0x80, /* 0001111110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0xff, 0x80, /* 1111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x1f, 0x80, /* 0001111110 */ + 0x0f, 0x80, /* 0000111110 */ + 0x07, 0x80, /* 0000011110 */ + 0x03, 0x80, /* 0000001110 */ + 0x01, 0x80, /* 0000000110 */ + 0x00, 0x80, /* 0000000010 */ + 0x00, 0x00, /* 0000000000 */ + + /* 17 0x11 '^Q' */ + 0x40, 0x00, /* 0100000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x70, 0x00, /* 0111000000 */ + 0x78, 0x00, /* 0111100000 */ + 0x7c, 0x00, /* 0111110000 */ + 0x7e, 0x00, /* 0111111000 */ + 0x7f, 0x00, /* 0111111100 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x00, /* 0111111100 */ + 0x7e, 0x00, /* 0111111000 */ + 0x7c, 0x00, /* 0111110000 */ + 0x78, 0x00, /* 0111100000 */ + 0x70, 0x00, /* 0111000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x40, 0x00, /* 0100000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 18 0x12 '^R' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x7f, 0x80, /* 0111111110 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 19 0x13 '^S' */ + 0x00, 0x00, /* 0000000000 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 20 0x14 '^T' */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x39, 0x80, /* 0011100110 */ + 0x79, 0x80, /* 0111100110 */ + 0x79, 0x80, /* 0111100110 */ + 0x79, 0x80, /* 0111100110 */ + 0x39, 0x80, /* 0011100110 */ + 0x19, 0x80, /* 0001100110 */ + 0x19, 0x80, /* 0001100110 */ + 0x19, 0x80, /* 0001100110 */ + 0x19, 0x80, /* 0001100110 */ + 0x19, 0x80, /* 0001100110 */ + 0x19, 0x80, /* 0001100110 */ + 0x39, 0xc0, /* 0011100111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 21 0x15 '^U' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 22 0x16 '^V' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 23 0x17 '^W' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x7f, 0x80, /* 0111111110 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 24 0x18 '^X' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x7f, 0x80, /* 0111111110 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 25 0x19 '^Y' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 26 0x1a '^Z' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x04, 0x00, /* 0000010000 */ + 0x06, 0x00, /* 0000011000 */ + 0x07, 0x00, /* 0000011100 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x07, 0x00, /* 0000011100 */ + 0x06, 0x00, /* 0000011000 */ + 0x04, 0x00, /* 0000010000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 27 0x1b '^[' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x08, 0x00, /* 0000100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x38, 0x00, /* 0011100000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x38, 0x00, /* 0011100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 28 0x1c '^\' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 29 0x1d '^]' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x12, 0x00, /* 0001001000 */ + 0x33, 0x00, /* 0011001100 */ + 0x73, 0x80, /* 0111001110 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x73, 0x80, /* 0111001110 */ + 0x33, 0x00, /* 0011001100 */ + 0x12, 0x00, /* 0001001000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 30 0x1e '^^' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x04, 0x00, /* 0000010000 */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x3f, 0x80, /* 0011111110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 31 0x1f '^_' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x3f, 0x80, /* 0011111110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x04, 0x00, /* 0000010000 */ + 0x04, 0x00, /* 0000010000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 32 0x20 ' ' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 33 0x21 '!' */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 34 0x22 '"' */ + 0x00, 0x00, /* 0000000000 */ + 0x63, 0x00, /* 0110001100 */ + 0xf7, 0x80, /* 1111011110 */ + 0xf7, 0x80, /* 1111011110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x63, 0x00, /* 0110001100 */ + 0x42, 0x00, /* 0100001000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 35 0x23 '#' */ + 0x00, 0x00, /* 0000000000 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 36 0x24 '$' */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x6f, 0x80, /* 0110111110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6c, 0x80, /* 0110110010 */ + 0x3c, 0x00, /* 0011110000 */ + 0x0f, 0x00, /* 0000111100 */ + 0x0d, 0x80, /* 0000110110 */ + 0x4d, 0x80, /* 0100110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x7f, 0x00, /* 0111111100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 37 0x25 '%' */ + 0x00, 0x00, /* 0000000000 */ + 0x31, 0x80, /* 0011000110 */ + 0x7b, 0x00, /* 0111101100 */ + 0x7b, 0x00, /* 0111101100 */ + 0x36, 0x00, /* 0011011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x37, 0x80, /* 0011011110 */ + 0x37, 0x80, /* 0011011110 */ + 0x63, 0x00, /* 0110001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 38 0x26 '&' */ + 0x00, 0x00, /* 0000000000 */ + 0x07, 0x00, /* 0000011100 */ + 0x0f, 0x80, /* 0000111110 */ + 0x19, 0x80, /* 0001100110 */ + 0x19, 0x80, /* 0001100110 */ + 0x0f, 0x80, /* 0000111110 */ + 0x1e, 0x00, /* 0001111000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x76, 0x00, /* 0111011000 */ + 0x66, 0x40, /* 0110011001 */ + 0x63, 0xc0, /* 0110001111 */ + 0x63, 0x80, /* 0110001110 */ + 0x63, 0x00, /* 0110001100 */ + 0x3f, 0x80, /* 0011111110 */ + 0x1c, 0xc0, /* 0001110011 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 39 0x27 ''' */ + 0x00, 0x00, /* 0000000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x78, 0x00, /* 0111100000 */ + 0x78, 0x00, /* 0111100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x20, 0x00, /* 0010000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 40 0x28 '(' */ + 0x00, 0x00, /* 0000000000 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x03, 0x00, /* 0000001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 41 0x29 ')' */ + 0x00, 0x00, /* 0000000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 42 0x2a '*' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x4c, 0x80, /* 0100110010 */ + 0x6d, 0x80, /* 0110110110 */ + 0x3f, 0x00, /* 0011111100 */ + 0x7f, 0x80, /* 0111111110 */ + 0x3f, 0x00, /* 0011111100 */ + 0x6d, 0x80, /* 0110110110 */ + 0x4c, 0x80, /* 0100110010 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 43 0x2b '+' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 44 0x2c ',' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x78, 0x00, /* 0111100000 */ + 0x78, 0x00, /* 0111100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x40, 0x00, /* 0100000000 */ + + /* 45 0x2d '-' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 46 0x2e '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 47 0x2f '/' */ + 0x00, 0x00, /* 0000000000 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 48 0x30 '0' */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x23, 0x00, /* 0010001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x63, 0x80, /* 0110001110 */ + 0x65, 0x80, /* 0110010110 */ + 0x65, 0x80, /* 0110010110 */ + 0x69, 0x80, /* 0110100110 */ + 0x69, 0x80, /* 0110100110 */ + 0x71, 0x80, /* 0111000110 */ + 0x61, 0x00, /* 0110000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 49 0x31 '1' */ + 0x00, 0x00, /* 0000000000 */ + 0x04, 0x00, /* 0000010000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 50 0x32 '2' */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x63, 0x80, /* 0110001110 */ + 0x41, 0x80, /* 0100000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x80, /* 0011000010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 51 0x33 '3' */ + 0x00, 0x00, /* 0000000000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x47, 0x00, /* 0100011100 */ + 0x03, 0x00, /* 0000001100 */ + 0x07, 0x00, /* 0000011100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x07, 0x00, /* 0000011100 */ + 0x03, 0x00, /* 0000001100 */ + 0x01, 0x80, /* 0000000110 */ + 0x41, 0x80, /* 0100000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 52 0x34 '4' */ + 0x00, 0x00, /* 0000000000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x66, 0x00, /* 0110011000 */ + 0x66, 0x00, /* 0110011000 */ + 0xc6, 0x00, /* 1100011000 */ + 0xc6, 0x00, /* 1100011000 */ + 0xff, 0x80, /* 1111111110 */ + 0xff, 0x80, /* 1111111110 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 53 0x35 '5' */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x7e, 0x00, /* 0111111000 */ + 0x67, 0x00, /* 0110011100 */ + 0x03, 0x80, /* 0000001110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x41, 0x80, /* 0100000110 */ + 0x63, 0x00, /* 0110001100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 54 0x36 '6' */ + 0x00, 0x00, /* 0000000000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x6e, 0x00, /* 0110111000 */ + 0x7f, 0x00, /* 0111111100 */ + 0x73, 0x80, /* 0111001110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x71, 0x00, /* 0111000100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 55 0x37 '7' */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x80, /* 0001111110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x61, 0x80, /* 0110000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 56 0x38 '8' */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x23, 0x00, /* 0010001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x31, 0x00, /* 0011000100 */ + 0x1a, 0x00, /* 0001101000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x16, 0x00, /* 0001011000 */ + 0x23, 0x00, /* 0010001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x31, 0x00, /* 0011000100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 57 0x39 '9' */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x17, 0x00, /* 0001011100 */ + 0x23, 0x80, /* 0010001110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x3d, 0x80, /* 0011110110 */ + 0x19, 0x80, /* 0001100110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 58 0x3a ':' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 59 0x3b ';' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x20, 0x00, /* 0010000000 */ + + /* 60 0x3c '<' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x03, 0x00, /* 0000001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 61 0x3d '=' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 62 0x3e '>' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x03, 0x00, /* 0000001100 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 63 0x3f '?' */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x3b, 0x80, /* 0011101110 */ + 0x21, 0x80, /* 0010000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 64 0x40 '@' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x65, 0x80, /* 0110010110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6f, 0x80, /* 0110111110 */ + 0x60, 0x00, /* 0110000000 */ + 0x31, 0x80, /* 0011000110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x0f, 0x00, /* 0000111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 65 0x41 'A' */ + 0x00, 0x00, /* 0000000000 */ + 0x04, 0x00, /* 0000010000 */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x19, 0x80, /* 0001100110 */ + 0x31, 0x80, /* 0011000110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x31, 0x80, /* 0011000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x60, 0xc0, /* 0110000011 */ + 0x60, 0xc0, /* 0110000011 */ + 0xf1, 0xc0, /* 1111000111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 66 0x42 'B' */ + 0x00, 0x00, /* 0000000000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x62, 0x00, /* 0110001000 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x66, 0x00, /* 0110011000 */ + 0x7e, 0x00, /* 0111111000 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x63, 0x00, /* 0110001100 */ + 0xfe, 0x00, /* 1111111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 67 0x43 'C' */ + 0x00, 0x00, /* 0000000000 */ + 0x0f, 0x00, /* 0000111100 */ + 0x11, 0x80, /* 0001000110 */ + 0x20, 0x80, /* 0010000010 */ + 0x20, 0x00, /* 0010000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x20, 0x00, /* 0010000000 */ + 0x30, 0x80, /* 0011000010 */ + 0x19, 0x00, /* 0001100100 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 68 0x44 'D' */ + 0x00, 0x00, /* 0000000000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x67, 0x00, /* 0110011100 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x00, /* 0110000100 */ + 0x66, 0x00, /* 0110011000 */ + 0xf8, 0x00, /* 1111100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 69 0x45 'E' */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x31, 0x00, /* 0011000100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x31, 0x00, /* 0011000100 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x80, /* 0011000010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 70 0x46 'F' */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x31, 0x00, /* 0011000100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x31, 0x00, /* 0011000100 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x78, 0x00, /* 0111100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 71 0x47 'G' */ + 0x00, 0x00, /* 0000000000 */ + 0x0f, 0x00, /* 0000111100 */ + 0x11, 0x80, /* 0001000110 */ + 0x20, 0x80, /* 0010000010 */ + 0x20, 0x00, /* 0010000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x67, 0xc0, /* 0110011111 */ + 0x61, 0x80, /* 0110000110 */ + 0x21, 0x80, /* 0010000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x19, 0x80, /* 0001100110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 72 0x48 'H' */ + 0x00, 0x00, /* 0000000000 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 73 0x49 'I' */ + 0x00, 0x00, /* 0000000000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 74 0x4a 'J' */ + 0x00, 0x00, /* 0000000000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x08, 0x00, /* 0000100000 */ + 0x70, 0x00, /* 0111000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 75 0x4b 'K' */ + 0x00, 0x00, /* 0000000000 */ + 0xf1, 0x80, /* 1111000110 */ + 0x63, 0x00, /* 0110001100 */ + 0x66, 0x00, /* 0110011000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x78, 0x00, /* 0111100000 */ + 0x70, 0x00, /* 0111000000 */ + 0x70, 0x00, /* 0111000000 */ + 0x78, 0x00, /* 0111100000 */ + 0x78, 0x00, /* 0111100000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x66, 0x00, /* 0110011000 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x80, /* 0110000110 */ + 0xf0, 0xc0, /* 1111000011 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 76 0x4c 'L' */ + 0x00, 0x00, /* 0000000000 */ + 0x78, 0x00, /* 0111100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x80, /* 0011000010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 77 0x4d 'M' */ + 0x00, 0x00, /* 0000000000 */ + 0xe0, 0xc0, /* 1110000011 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x73, 0x80, /* 0111001110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 78 0x4e 'N' */ + 0x00, 0x00, /* 0000000000 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x71, 0x80, /* 0111000110 */ + 0x79, 0x80, /* 0111100110 */ + 0x79, 0x80, /* 0111100110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x67, 0x80, /* 0110011110 */ + 0x67, 0x80, /* 0110011110 */ + 0x63, 0x80, /* 0110001110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 79 0x4f 'O' */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x17, 0x00, /* 0001011100 */ + 0x23, 0x00, /* 0010001100 */ + 0x21, 0x80, /* 0010000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x21, 0x00, /* 0010000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x1a, 0x00, /* 0001101000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 80 0x50 'P' */ + 0x00, 0x00, /* 0000000000 */ + 0xfe, 0x00, /* 1111111000 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x63, 0x00, /* 0110001100 */ + 0x7e, 0x00, /* 0111111000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0xf0, 0x00, /* 1111000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 81 0x51 'Q' */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x13, 0x00, /* 0001001100 */ + 0x23, 0x00, /* 0010001100 */ + 0x21, 0x80, /* 0010000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x3b, 0x00, /* 0011101100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x26, 0x00, /* 0010011000 */ + 0x03, 0x80, /* 0000001110 */ + 0x00, 0x00, /* 0000000000 */ + + /* 82 0x52 'R' */ + 0x00, 0x00, /* 0000000000 */ + 0xfe, 0x00, /* 1111111000 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x00, /* 0110000100 */ + 0x7e, 0x00, /* 0111111000 */ + 0x78, 0x00, /* 0111100000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x6e, 0x00, /* 0110111000 */ + 0x67, 0x00, /* 0110011100 */ + 0x63, 0x80, /* 0110001110 */ + 0x61, 0xc0, /* 0110000111 */ + 0xf0, 0xc0, /* 1111000011 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 83 0x53 'S' */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x03, 0x00, /* 0000001100 */ + 0x01, 0x80, /* 0000000110 */ + 0x41, 0x80, /* 0100000110 */ + 0x63, 0x00, /* 0110001100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 84 0x54 'T' */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x4c, 0x80, /* 0100110010 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 85 0x55 'U' */ + 0x00, 0x00, /* 0000000000 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x00, /* 0111001100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 86 0x56 'V' */ + 0x00, 0x00, /* 0000000000 */ + 0xe1, 0xc0, /* 1110000111 */ + 0xc0, 0xc0, /* 1100000011 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x12, 0x00, /* 0001001000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 87 0x57 'W' */ + 0x00, 0x00, /* 0000000000 */ + 0xe1, 0xc0, /* 1110000111 */ + 0xc0, 0xc0, /* 1100000011 */ + 0xc0, 0xc0, /* 1100000011 */ + 0xc0, 0xc0, /* 1100000011 */ + 0xe0, 0xc0, /* 1110000011 */ + 0x61, 0x80, /* 0110000110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x77, 0x00, /* 0111011100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 88 0x58 'X' */ + 0x00, 0x00, /* 0000000000 */ + 0xf7, 0x80, /* 1111011110 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0xf7, 0x80, /* 1111011110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 89 0x59 'Y' */ + 0x00, 0x00, /* 0000000000 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 90 0x5a 'Z' */ + 0x00, 0x00, /* 0000000000 */ + 0x3f, 0x80, /* 0011111110 */ + 0x21, 0x80, /* 0010000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x80, /* 0011000010 */ + 0x3f, 0x80, /* 0011111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 91 0x5b '[' */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x1f, 0x00, /* 0001111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 92 0x5c '\' */ + 0x00, 0x00, /* 0000000000 */ + 0xc0, 0x00, /* 1100000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x00, 0xc0, /* 0000000011 */ + 0x00, 0x00, /* 0000000000 */ + + /* 93 0x5d ']' */ + 0x00, 0x00, /* 0000000000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 94 0x5e '^' */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 95 0x5f '_' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + + /* 96 0x60 '`' */ + 0x04, 0x00, /* 0000010000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 97 0x61 'a' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x21, 0x80, /* 0010000110 */ + 0x07, 0x80, /* 0000011110 */ + 0x39, 0x80, /* 0011100110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x3d, 0xc0, /* 0011110111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 98 0x62 'b' */ + 0x20, 0x00, /* 0010000000 */ + 0x60, 0x00, /* 0110000000 */ + 0xe0, 0x00, /* 1110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x66, 0x00, /* 0110011000 */ + 0x6f, 0x00, /* 0110111100 */ + 0x73, 0x80, /* 0111001110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x71, 0x80, /* 0111000110 */ + 0x7b, 0x00, /* 0111101100 */ + 0x4e, 0x00, /* 0100111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 99 0x63 'c' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x37, 0x00, /* 0011011100 */ + 0x23, 0x00, /* 0010001100 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x71, 0x00, /* 0111000100 */ + 0x33, 0x00, /* 0011001100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 100 0x64 'd' */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x80, /* 0000001110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x0d, 0x80, /* 0000110110 */ + 0x37, 0x80, /* 0011011110 */ + 0x23, 0x80, /* 0010001110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x35, 0x80, /* 0011010110 */ + 0x19, 0xc0, /* 0001100111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 101 0x65 'e' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x19, 0x80, /* 0001100110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 102 0x66 'f' */ + 0x07, 0x00, /* 0000011100 */ + 0x09, 0x80, /* 0000100110 */ + 0x09, 0x80, /* 0000100110 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x7f, 0x00, /* 0111111100 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 103 0x67 'g' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1c, 0x80, /* 0001110010 */ + 0x37, 0x80, /* 0011011110 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x36, 0x00, /* 0011011000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x60, 0x00, /* 0110000000 */ + 0x7f, 0x00, /* 0111111100 */ + 0x3f, 0x80, /* 0011111110 */ + 0x21, 0x80, /* 0010000110 */ + 0x40, 0x80, /* 0100000010 */ + 0x7f, 0x00, /* 0111111100 */ + 0x3e, 0x00, /* 0011111000 */ + + /* 104 0x68 'h' */ + 0x10, 0x00, /* 0001000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x70, 0x00, /* 0111000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x37, 0x00, /* 0011011100 */ + 0x3b, 0x80, /* 0011101110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x7b, 0xc0, /* 0111101111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 105 0x69 'i' */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 106 0x6a 'j' */ + 0x00, 0x00, /* 0000000000 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x07, 0x80, /* 0000011110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x41, 0x80, /* 0100000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x71, 0x80, /* 0111000110 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1c, 0x00, /* 0001110000 */ + + /* 107 0x6b 'k' */ + 0x60, 0x00, /* 0110000000 */ + 0xe0, 0x00, /* 1110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x63, 0x80, /* 0110001110 */ + 0x66, 0x00, /* 0110011000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x78, 0x00, /* 0111100000 */ + 0x70, 0x00, /* 0111000000 */ + 0x78, 0x00, /* 0111100000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x6e, 0x00, /* 0110111000 */ + 0x67, 0x00, /* 0110011100 */ + 0xf3, 0x80, /* 1111001110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 108 0x6c 'l' */ + 0x3c, 0x00, /* 0011110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 109 0x6d 'm' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xdb, 0x80, /* 1101101110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0xed, 0xc0, /* 1110110111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 110 0x6e 'n' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x6f, 0x00, /* 0110111100 */ + 0x7b, 0x80, /* 0111101110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x7b, 0xc0, /* 0111101111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 111 0x6f 'o' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x66, 0x00, /* 0110011000 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xe1, 0x80, /* 1110000110 */ + 0x73, 0x00, /* 0111001100 */ + 0x3c, 0x00, /* 0011110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 112 0x70 'p' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xde, 0x00, /* 1101111000 */ + 0x76, 0x00, /* 0111011000 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x71, 0x80, /* 0111000110 */ + 0x7b, 0x00, /* 0111101100 */ + 0x7e, 0x00, /* 0111111000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0xf0, 0x00, /* 1111000000 */ + + /* 113 0x71 'q' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0xc0, /* 0000111011 */ + 0x1b, 0x80, /* 0001101110 */ + 0x33, 0x80, /* 0011001110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x71, 0x80, /* 0111000110 */ + 0x3b, 0x80, /* 0011101110 */ + 0x1f, 0x80, /* 0001111110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0xc0, /* 0000001111 */ + + /* 114 0x72 'r' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x73, 0x00, /* 0111001100 */ + 0x35, 0x80, /* 0011010110 */ + 0x39, 0x80, /* 0011100110 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x78, 0x00, /* 0111100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 115 0x73 's' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x00, /* 0110000100 */ + 0x70, 0x00, /* 0111000000 */ + 0x38, 0x00, /* 0011100000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x07, 0x00, /* 0000011100 */ + 0x43, 0x00, /* 0100001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x7e, 0x00, /* 0111111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 116 0x74 't' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x1c, 0x80, /* 0001110010 */ + 0x0f, 0x00, /* 0000111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 117 0x75 'u' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xf7, 0x80, /* 1111011110 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x77, 0x00, /* 0111011100 */ + 0x3d, 0x80, /* 0011110110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 118 0x76 'v' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xf1, 0xc0, /* 1111000111 */ + 0x60, 0xc0, /* 0110000011 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x19, 0x80, /* 0001100110 */ + 0x1b, 0x00, /* 0001101100 */ + 0x0f, 0x00, /* 0000111100 */ + 0x0f, 0x00, /* 0000111100 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 119 0x77 'w' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xe3, 0xc0, /* 1110001111 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0x6b, 0x00, /* 0110101100 */ + 0x6b, 0x00, /* 0110101100 */ + 0x7e, 0x00, /* 0111111000 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 120 0x78 'x' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xf7, 0x80, /* 1111011110 */ + 0x63, 0x00, /* 0110001100 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x36, 0x00, /* 0011011000 */ + 0x66, 0x00, /* 0110011000 */ + 0x63, 0x00, /* 0110001100 */ + 0xf7, 0x80, /* 1111011110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 121 0x79 'y' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x61, 0x80, /* 0110000110 */ + 0x33, 0x00, /* 0011001100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x78, 0x00, /* 0111100000 */ + 0x70, 0x00, /* 0111000000 */ + + /* 122 0x7a 'z' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x61, 0x80, /* 0110000110 */ + 0x43, 0x00, /* 0100001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x60, 0x80, /* 0110000010 */ + 0x61, 0x80, /* 0110000110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 123 0x7b '{' */ + 0x07, 0x00, /* 0000011100 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x70, 0x00, /* 0111000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x07, 0x00, /* 0000011100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 124 0x7c '|' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 125 0x7d '}' */ + 0x38, 0x00, /* 0011100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x03, 0x80, /* 0000001110 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x38, 0x00, /* 0011100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 126 0x7e '~' */ + 0x00, 0x00, /* 0000000000 */ + 0x18, 0x80, /* 0001100010 */ + 0x3d, 0x80, /* 0011110110 */ + 0x6f, 0x00, /* 0110111100 */ + 0x46, 0x00, /* 0100011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 127 0x7f '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x12, 0x00, /* 0001001000 */ + 0x21, 0x00, /* 0010000100 */ + 0x40, 0x80, /* 0100000010 */ + 0x40, 0x80, /* 0100000010 */ + 0x40, 0x80, /* 0100000010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 128 0x80 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x21, 0x80, /* 0010000110 */ + 0x40, 0x80, /* 0100000010 */ + 0x40, 0x00, /* 0100000000 */ + 0x40, 0x00, /* 0100000000 */ + 0x40, 0x00, /* 0100000000 */ + 0x40, 0x00, /* 0100000000 */ + 0x40, 0x00, /* 0100000000 */ + 0x40, 0x00, /* 0100000000 */ + 0x60, 0x80, /* 0110000010 */ + 0x31, 0x00, /* 0011000100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x08, 0x00, /* 0000100000 */ + 0x04, 0x00, /* 0000010000 */ + 0x02, 0x00, /* 0000001000 */ + 0x02, 0x00, /* 0000001000 */ + 0x1c, 0x00, /* 0001110000 */ + + /* 129 0x81 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7b, 0x80, /* 0111101110 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x3b, 0x00, /* 0011101100 */ + 0x1c, 0x80, /* 0001110010 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 130 0x82 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x01, 0x00, /* 0000000100 */ + 0x02, 0x00, /* 0000001000 */ + 0x04, 0x00, /* 0000010000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x19, 0x80, /* 0001100110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 131 0x83 '.' */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x31, 0x80, /* 0011000110 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x21, 0x80, /* 0010000110 */ + 0x07, 0x80, /* 0000011110 */ + 0x39, 0x80, /* 0011100110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x3d, 0xc0, /* 0011110111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 132 0x84 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x21, 0x80, /* 0010000110 */ + 0x07, 0x80, /* 0000011110 */ + 0x39, 0x80, /* 0011100110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x3d, 0xc0, /* 0011110111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 133 0x85 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x21, 0x80, /* 0010000110 */ + 0x07, 0x80, /* 0000011110 */ + 0x39, 0x80, /* 0011100110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x3d, 0xc0, /* 0011110111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 134 0x86 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x21, 0x80, /* 0010000110 */ + 0x07, 0x80, /* 0000011110 */ + 0x39, 0x80, /* 0011100110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x3d, 0xc0, /* 0011110111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 135 0x87 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x20, 0x80, /* 0010000010 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x70, 0x80, /* 0111000010 */ + 0x30, 0x80, /* 0011000010 */ + 0x1f, 0x00, /* 0001111100 */ + 0x04, 0x00, /* 0000010000 */ + 0x02, 0x00, /* 0000001000 */ + 0x01, 0x00, /* 0000000100 */ + 0x0e, 0x00, /* 0000111000 */ + + /* 136 0x88 '.' */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x31, 0x80, /* 0011000110 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x19, 0x80, /* 0001100110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 137 0x89 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x19, 0x80, /* 0001100110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 138 0x8a '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x19, 0x80, /* 0001100110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 139 0x8b '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x36, 0x00, /* 0011011000 */ + 0x36, 0x00, /* 0011011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 140 0x8c '.' */ + 0x08, 0x00, /* 0000100000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x36, 0x00, /* 0011011000 */ + 0x63, 0x00, /* 0110001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 141 0x8d '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 142 0x8e '.' */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x04, 0x00, /* 0000010000 */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x19, 0x00, /* 0001100100 */ + 0x19, 0x00, /* 0001100100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 143 0x8f '.' */ + 0x04, 0x00, /* 0000010000 */ + 0x0a, 0x00, /* 0000101000 */ + 0x0a, 0x00, /* 0000101000 */ + 0x04, 0x00, /* 0000010000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x19, 0x00, /* 0001100100 */ + 0x19, 0x00, /* 0001100100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 144 0x90 '.' */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x00, /* 0011000000 */ + 0x31, 0x00, /* 0011000100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x31, 0x00, /* 0011000100 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x80, /* 0011000010 */ + 0x30, 0x80, /* 0011000010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 145 0x91 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3b, 0x80, /* 0011101110 */ + 0x6c, 0xc0, /* 0110110011 */ + 0x4c, 0xc0, /* 0100110011 */ + 0x0c, 0xc0, /* 0000110011 */ + 0x3f, 0xc0, /* 0011111111 */ + 0x6c, 0x00, /* 0110110000 */ + 0xcc, 0x00, /* 1100110000 */ + 0xcc, 0x00, /* 1100110000 */ + 0xee, 0xc0, /* 1110111011 */ + 0x7b, 0x80, /* 0111101110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 146 0x92 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x07, 0xc0, /* 0000011111 */ + 0x0e, 0x40, /* 0000111001 */ + 0x0e, 0x40, /* 0000111001 */ + 0x0e, 0x00, /* 0000111000 */ + 0x16, 0x00, /* 0001011000 */ + 0x16, 0x80, /* 0001011010 */ + 0x17, 0x80, /* 0001011110 */ + 0x16, 0x80, /* 0001011010 */ + 0x3e, 0x00, /* 0011111000 */ + 0x26, 0x00, /* 0010011000 */ + 0x26, 0x00, /* 0010011000 */ + 0x46, 0x40, /* 0100011001 */ + 0x46, 0x40, /* 0100011001 */ + 0xef, 0xc0, /* 1110111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 147 0x93 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x08, 0x00, /* 0000100000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x36, 0x00, /* 0011011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x66, 0x00, /* 0110011000 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xe1, 0x80, /* 1110000110 */ + 0x73, 0x00, /* 0111001100 */ + 0x3c, 0x00, /* 0011110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 148 0x94 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x66, 0x00, /* 0110011000 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xe1, 0x80, /* 1110000110 */ + 0x73, 0x00, /* 0111001100 */ + 0x3c, 0x00, /* 0011110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 149 0x95 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x06, 0x00, /* 0000011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x66, 0x00, /* 0110011000 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xe1, 0x80, /* 1110000110 */ + 0x73, 0x00, /* 0111001100 */ + 0x3c, 0x00, /* 0011110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 150 0x96 '.' */ + 0x08, 0x00, /* 0000100000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x36, 0x00, /* 0011011000 */ + 0x63, 0x00, /* 0110001100 */ + 0x00, 0x00, /* 0000000000 */ + 0xf7, 0x80, /* 1111011110 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x77, 0x00, /* 0111011100 */ + 0x3d, 0x80, /* 0011110110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 151 0x97 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0xf7, 0x80, /* 1111011110 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x77, 0x00, /* 0111011100 */ + 0x3d, 0x80, /* 0011110110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 152 0x98 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x61, 0x80, /* 0110000110 */ + 0x33, 0x00, /* 0011001100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x78, 0x00, /* 0111100000 */ + 0x70, 0x00, /* 0111000000 */ + + /* 153 0x99 '.' */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x0c, 0x00, /* 0000110000 */ + 0x17, 0x00, /* 0001011100 */ + 0x23, 0x00, /* 0010001100 */ + 0x21, 0x80, /* 0010000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x21, 0x00, /* 0010000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x1a, 0x00, /* 0001101000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 154 0x9a '.' */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0xf1, 0xc0, /* 1111000111 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0x60, 0x80, /* 0110000010 */ + 0x71, 0x00, /* 0111000100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 155 0x9b '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x1f, 0x80, /* 0001111110 */ + 0x36, 0x80, /* 0011011010 */ + 0x26, 0x00, /* 0010011000 */ + 0x66, 0x00, /* 0110011000 */ + 0x66, 0x00, /* 0110011000 */ + 0x66, 0x00, /* 0110011000 */ + 0x66, 0x00, /* 0110011000 */ + 0x76, 0x00, /* 0111011000 */ + 0x36, 0x80, /* 0011011010 */ + 0x1f, 0x80, /* 0001111110 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 156 0x9c '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x3b, 0x00, /* 0011101100 */ + 0x33, 0x00, /* 0011001100 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x7e, 0x00, /* 0111111000 */ + 0x7e, 0x00, /* 0111111000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x7c, 0x80, /* 0111110010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x43, 0x00, /* 0100001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 157 0x9d '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x40, 0x80, /* 0100000010 */ + 0x40, 0x80, /* 0100000010 */ + 0x21, 0x00, /* 0010000100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 158 0x9e '.' */ + 0x00, 0x00, /* 0000000000 */ + 0xbf, 0x00, /* 1011111100 */ + 0x40, 0x80, /* 0100000010 */ + 0x40, 0x80, /* 0100000010 */ + 0x7f, 0x00, /* 0111111100 */ + 0x40, 0x00, /* 0100000000 */ + 0x48, 0x00, /* 0100100000 */ + 0x48, 0x00, /* 0100100000 */ + 0x5e, 0x00, /* 0101111000 */ + 0x48, 0x00, /* 0100100000 */ + 0x48, 0x00, /* 0100100000 */ + 0x48, 0x00, /* 0100100000 */ + 0x48, 0x80, /* 0100100010 */ + 0x47, 0x00, /* 0100011100 */ + 0xe0, 0x00, /* 1110000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 159 0x9f '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x03, 0x00, /* 0000001100 */ + 0x04, 0x80, /* 0000010010 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x09, 0x00, /* 0000100100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x48, 0x00, /* 0100100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x08, 0x00, /* 0000100000 */ + 0x90, 0x00, /* 1001000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 160 0xa0 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x21, 0x80, /* 0010000110 */ + 0x07, 0x80, /* 0000011110 */ + 0x39, 0x80, /* 0011100110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x3d, 0xc0, /* 0011110111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 161 0xa1 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x03, 0x00, /* 0000001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 162 0xa2 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x66, 0x00, /* 0110011000 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xc1, 0x80, /* 1100000110 */ + 0xe1, 0x80, /* 1110000110 */ + 0x73, 0x00, /* 0111001100 */ + 0x3c, 0x00, /* 0011110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 163 0xa3 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0xf7, 0x80, /* 1111011110 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x77, 0x00, /* 0111011100 */ + 0x3d, 0x80, /* 0011110110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 164 0xa4 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x38, 0x80, /* 0011100010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x47, 0x00, /* 0100011100 */ + 0x00, 0x00, /* 0000000000 */ + 0x6f, 0x00, /* 0110111100 */ + 0x7b, 0x80, /* 0111101110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x7b, 0xc0, /* 0111101111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 165 0xa5 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x38, 0x80, /* 0011100010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x47, 0x00, /* 0100011100 */ + 0x00, 0x00, /* 0000000000 */ + 0xe3, 0xc0, /* 1110001111 */ + 0x71, 0x80, /* 0111000110 */ + 0x79, 0x80, /* 0111100110 */ + 0x79, 0x80, /* 0111100110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x67, 0x80, /* 0110011110 */ + 0x63, 0x80, /* 0110001110 */ + 0x61, 0x80, /* 0110000110 */ + 0xf0, 0xc0, /* 1111000011 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 166 0xa6 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x63, 0x00, /* 0110001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x0f, 0x00, /* 0000111100 */ + 0x33, 0x00, /* 0011001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x67, 0x00, /* 0110011100 */ + 0x3b, 0x80, /* 0011101110 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 167 0xa7 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x21, 0x80, /* 0010000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x00, /* 0110000100 */ + 0x33, 0x00, /* 0011001100 */ + 0x1c, 0x00, /* 0001110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 168 0xa8 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x00, 0x00, /* 0000000000 */ + 0x06, 0x00, /* 0000011000 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x80, /* 0110000010 */ + 0x73, 0x80, /* 0111001110 */ + 0x3f, 0x00, /* 0011111100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 169 0xa9 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 170 0xaa '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 171 0xab '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x20, 0x00, /* 0010000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x20, 0x00, /* 0010000000 */ + 0x20, 0x80, /* 0010000010 */ + 0x21, 0x00, /* 0010000100 */ + 0x22, 0x00, /* 0010001000 */ + 0x74, 0x00, /* 0111010000 */ + 0x08, 0x00, /* 0000100000 */ + 0x17, 0x00, /* 0001011100 */ + 0x28, 0x80, /* 0010100010 */ + 0x43, 0x00, /* 0100001100 */ + 0x04, 0x00, /* 0000010000 */ + 0x08, 0x00, /* 0000100000 */ + 0x0f, 0x80, /* 0000111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 172 0xac '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x20, 0x00, /* 0010000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x20, 0x00, /* 0010000000 */ + 0x20, 0x80, /* 0010000010 */ + 0x21, 0x00, /* 0010000100 */ + 0x22, 0x00, /* 0010001000 */ + 0x74, 0x00, /* 0111010000 */ + 0x09, 0x00, /* 0000100100 */ + 0x13, 0x00, /* 0001001100 */ + 0x25, 0x00, /* 0010010100 */ + 0x49, 0x00, /* 0100100100 */ + 0x1f, 0x80, /* 0001111110 */ + 0x01, 0x00, /* 0000000100 */ + 0x01, 0x00, /* 0000000100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 173 0xad '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 174 0xae '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0d, 0x80, /* 0000110110 */ + 0x1b, 0x00, /* 0001101100 */ + 0x36, 0x00, /* 0011011000 */ + 0x6c, 0x00, /* 0110110000 */ + 0xd8, 0x00, /* 1101100000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x36, 0x00, /* 0011011000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x0d, 0x80, /* 0000110110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 175 0xaf '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x36, 0x00, /* 0011011000 */ + 0x1b, 0x00, /* 0001101100 */ + 0x0d, 0x80, /* 0000110110 */ + 0x06, 0xc0, /* 0000011011 */ + 0x0d, 0x80, /* 0000110110 */ + 0x1b, 0x00, /* 0001101100 */ + 0x36, 0x00, /* 0011011000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 176 0xb0 '.' */ + 0xc3, 0x00, /* 1100001100 */ + 0x41, 0x00, /* 0100000100 */ + 0x18, 0x40, /* 0001100001 */ + 0x10, 0x40, /* 0001000001 */ + 0xc3, 0x00, /* 1100001100 */ + 0x41, 0x00, /* 0100000100 */ + 0x18, 0x40, /* 0001100001 */ + 0x10, 0x40, /* 0001000001 */ + 0xc3, 0x00, /* 1100001100 */ + 0x41, 0x00, /* 0100000100 */ + 0x18, 0x40, /* 0001100001 */ + 0x10, 0x40, /* 0001000001 */ + 0xc3, 0x00, /* 1100001100 */ + 0x41, 0x00, /* 0100000100 */ + 0x18, 0x40, /* 0001100001 */ + 0x10, 0x40, /* 0001000001 */ + 0xc3, 0x00, /* 1100001100 */ + 0x41, 0x00, /* 0100000100 */ + + /* 177 0xb1 '.' */ + 0x11, 0x00, /* 0001000100 */ + 0xbb, 0x80, /* 1011101110 */ + 0x11, 0x00, /* 0001000100 */ + 0x44, 0x40, /* 0100010001 */ + 0xee, 0xc0, /* 1110111011 */ + 0x44, 0x40, /* 0100010001 */ + 0x11, 0x00, /* 0001000100 */ + 0xbb, 0x80, /* 1011101110 */ + 0x11, 0x00, /* 0001000100 */ + 0x44, 0x40, /* 0100010001 */ + 0xee, 0xc0, /* 1110111011 */ + 0x44, 0x40, /* 0100010001 */ + 0x11, 0x00, /* 0001000100 */ + 0xbb, 0x80, /* 1011101110 */ + 0x11, 0x00, /* 0001000100 */ + 0x44, 0x40, /* 0100010001 */ + 0xee, 0xc0, /* 1110111011 */ + 0x44, 0x40, /* 0100010001 */ + + /* 178 0xb2 '.' */ + 0x3c, 0xc0, /* 0011110011 */ + 0xbe, 0xc0, /* 1011111011 */ + 0xe7, 0x80, /* 1110011110 */ + 0xef, 0x80, /* 1110111110 */ + 0x3c, 0xc0, /* 0011110011 */ + 0xbe, 0xc0, /* 1011111011 */ + 0xe7, 0x80, /* 1110011110 */ + 0xef, 0x80, /* 1110111110 */ + 0x3c, 0xc0, /* 0011110011 */ + 0xbe, 0xc0, /* 1011111011 */ + 0xe7, 0x80, /* 1110011110 */ + 0xef, 0x80, /* 1110111110 */ + 0x3c, 0xc0, /* 0011110011 */ + 0xbe, 0xc0, /* 1011111011 */ + 0xe7, 0x80, /* 1110011110 */ + 0xef, 0x80, /* 1110111110 */ + 0x3c, 0xc0, /* 0011110011 */ + 0xbe, 0xc0, /* 1011111011 */ + + /* 179 0xb3 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 180 0xb4 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 181 0xb5 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 182 0xb6 '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0xfb, 0x00, /* 1111101100 */ + 0xfb, 0x00, /* 1111101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 183 0xb7 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0x00, /* 1111111100 */ + 0xff, 0x00, /* 1111111100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 184 0xb8 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 185 0xb9 '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0xfb, 0x00, /* 1111101100 */ + 0xfb, 0x00, /* 1111101100 */ + 0x03, 0x00, /* 0000001100 */ + 0xfb, 0x00, /* 1111101100 */ + 0xfb, 0x00, /* 1111101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 186 0xba '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 187 0xbb '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0x00, /* 1111111100 */ + 0xff, 0x00, /* 1111111100 */ + 0x03, 0x00, /* 0000001100 */ + 0xfb, 0x00, /* 1111101100 */ + 0xfb, 0x00, /* 1111101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 188 0xbc '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0xfb, 0x00, /* 1111101100 */ + 0xfb, 0x00, /* 1111101100 */ + 0x03, 0x00, /* 0000001100 */ + 0xff, 0x00, /* 1111111100 */ + 0xff, 0x00, /* 1111111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 189 0xbd '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0xff, 0x00, /* 1111111100 */ + 0xff, 0x00, /* 1111111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 190 0xbe '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 191 0xbf '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 192 0xc0 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 193 0xc1 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 194 0xc2 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 195 0xc3 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 196 0xc4 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 197 0xc5 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 198 0xc6 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 199 0xc7 '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 200 0xc8 '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x18, 0x00, /* 0001100000 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 201 0xc9 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x18, 0x00, /* 0001100000 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 202 0xca '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0xfb, 0xc0, /* 1111101111 */ + 0xfb, 0xc0, /* 1111101111 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 203 0xcb '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0xfb, 0xc0, /* 1111101111 */ + 0xfb, 0xc0, /* 1111101111 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 204 0xcc '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x18, 0x00, /* 0001100000 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x1b, 0xc0, /* 0001101111 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 205 0xcd '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 206 0xce '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0xfb, 0xc0, /* 1111101111 */ + 0xfb, 0xc0, /* 1111101111 */ + 0x00, 0x00, /* 0000000000 */ + 0xfb, 0xc0, /* 1111101111 */ + 0xfb, 0xc0, /* 1111101111 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 207 0xcf '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 208 0xd0 '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 209 0xd1 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 210 0xd2 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 211 0xd3 '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 212 0xd4 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 213 0xd5 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 214 0xd6 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 215 0xd7 '.' */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + 0x1b, 0x00, /* 0001101100 */ + + /* 216 0xd8 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 217 0xd9 '.' */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0xfc, 0x00, /* 1111110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 218 0xda '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + + /* 219 0xdb '.' */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + + /* 220 0xdc '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + + /* 221 0xdd '.' */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + 0xf8, 0x00, /* 1111100000 */ + + /* 222 0xde '.' */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + 0x07, 0xc0, /* 0000011111 */ + + /* 223 0xdf '.' */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0xff, 0xc0, /* 1111111111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 224 0xe0 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1c, 0x80, /* 0001110010 */ + 0x35, 0x80, /* 0011010110 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x63, 0x00, /* 0110001100 */ + 0x37, 0x80, /* 0011011110 */ + 0x1c, 0x80, /* 0001110010 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 225 0xe1 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x63, 0x00, /* 0110001100 */ + 0x6f, 0x00, /* 0110111100 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x63, 0x00, /* 0110001100 */ + 0x6e, 0x00, /* 0110111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 226 0xe2 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 227 0xe3 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 228 0xe4 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0x80, /* 1111111110 */ + 0x60, 0x00, /* 0110000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x80, /* 0011000010 */ + 0x61, 0x80, /* 0110000110 */ + 0xff, 0x80, /* 1111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 229 0xe5 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1f, 0xc0, /* 0001111111 */ + 0x36, 0x00, /* 0011011000 */ + 0x63, 0x00, /* 0110001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x33, 0x00, /* 0011001100 */ + 0x3e, 0x00, /* 0011111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 230 0xe6 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x73, 0x80, /* 0111001110 */ + 0x6d, 0x80, /* 0110110110 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0xc0, 0x00, /* 1100000000 */ + + /* 231 0xe7 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x01, 0x80, /* 0000000110 */ + 0x36, 0x40, /* 0011011001 */ + 0x5e, 0x00, /* 0101111000 */ + 0x8c, 0x00, /* 1000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 232 0xe8 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x33, 0x00, /* 0011001100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 233 0xe9 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x1f, 0x00, /* 0001111100 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x60, 0xc0, /* 0110000011 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x7f, 0xc0, /* 0111111111 */ + 0x60, 0xc0, /* 0110000011 */ + 0x31, 0x80, /* 0011000110 */ + 0x31, 0x80, /* 0011000110 */ + 0x1f, 0x00, /* 0001111100 */ + 0x0e, 0x00, /* 0000111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 234 0xea '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0xc0, 0xc0, /* 1100000011 */ + 0xc0, 0xc0, /* 1100000011 */ + 0xc0, 0xc0, /* 1100000011 */ + 0x61, 0x80, /* 0110000110 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0xf3, 0xc0, /* 1111001111 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 235 0xeb '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x07, 0x00, /* 0000011100 */ + 0x1f, 0x80, /* 0001111110 */ + 0x30, 0xc0, /* 0011000011 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x3e, 0x00, /* 0011111000 */ + 0x66, 0x00, /* 0110011000 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc3, 0x00, /* 1100001100 */ + 0xc3, 0x00, /* 1100001100 */ + 0x66, 0x00, /* 0110011000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 236 0xec '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x33, 0x00, /* 0011001100 */ + 0x6d, 0x80, /* 0110110110 */ + 0xcc, 0xc0, /* 1100110011 */ + 0xcc, 0xc0, /* 1100110011 */ + 0xcc, 0xc0, /* 1100110011 */ + 0xcc, 0xc0, /* 1100110011 */ + 0x6d, 0x80, /* 0110110110 */ + 0x33, 0x00, /* 0011001100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 237 0xed '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x01, 0x80, /* 0000000110 */ + 0x01, 0x80, /* 0000000110 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x37, 0x00, /* 0011011100 */ + 0x6d, 0x80, /* 0110110110 */ + 0xcc, 0xc0, /* 1100110011 */ + 0xcc, 0xc0, /* 1100110011 */ + 0xcc, 0xc0, /* 1100110011 */ + 0xcc, 0xc0, /* 1100110011 */ + 0x6d, 0x80, /* 0110110110 */ + 0x3b, 0x00, /* 0011101100 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x60, 0x00, /* 0110000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 238 0xee '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x03, 0x80, /* 0000001110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x3f, 0x80, /* 0011111110 */ + 0x3f, 0x80, /* 0011111110 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x18, 0x00, /* 0001100000 */ + 0x18, 0x00, /* 0001100000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x03, 0x80, /* 0000001110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 239 0xef '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x61, 0x80, /* 0110000110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 240 0xf0 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 241 0xf1 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 242 0xf2 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xe0, 0x00, /* 1110000000 */ + 0x38, 0x00, /* 0011100000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x03, 0x80, /* 0000001110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x38, 0x00, /* 0011100000 */ + 0xe0, 0x00, /* 1110000000 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0x00, /* 1111111100 */ + 0xff, 0x00, /* 1111111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 243 0xf3 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x03, 0x80, /* 0000001110 */ + 0x0e, 0x00, /* 0000111000 */ + 0x38, 0x00, /* 0011100000 */ + 0xe0, 0x00, /* 1110000000 */ + 0x38, 0x00, /* 0011100000 */ + 0x0e, 0x00, /* 0000111000 */ + 0x03, 0x80, /* 0000001110 */ + 0x00, 0x00, /* 0000000000 */ + 0xff, 0x80, /* 1111111110 */ + 0xff, 0x80, /* 1111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 244 0xf4 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x30, 0x00, /* 0011000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 245 0xf5 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x03, 0x00, /* 0000001100 */ + 0x00, 0x00, /* 0000000000 */ + + /* 246 0xf6 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 247 0xf7 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x38, 0x00, /* 0011100000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x06, 0xc0, /* 0000011011 */ + 0x03, 0x80, /* 0000001110 */ + 0x38, 0x00, /* 0011100000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x06, 0xc0, /* 0000011011 */ + 0x03, 0x80, /* 0000001110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 248 0xf8 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x33, 0x00, /* 0011001100 */ + 0x33, 0x00, /* 0011001100 */ + 0x1e, 0x00, /* 0001111000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 249 0xf9 '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 250 0xfa '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 251 0xfb '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0f, 0xc0, /* 0000111111 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0xcc, 0x00, /* 1100110000 */ + 0x6c, 0x00, /* 0110110000 */ + 0x3c, 0x00, /* 0011110000 */ + 0x1c, 0x00, /* 0001110000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 252 0xfc '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x27, 0x00, /* 0010011100 */ + 0x7b, 0x00, /* 0111101100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x31, 0x00, /* 0011000100 */ + 0x7b, 0x80, /* 0111101110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 253 0xfd '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x1e, 0x00, /* 0001111000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x63, 0x00, /* 0110001100 */ + 0x43, 0x00, /* 0100001100 */ + 0x06, 0x00, /* 0000011000 */ + 0x0c, 0x00, /* 0000110000 */ + 0x18, 0x00, /* 0001100000 */ + 0x30, 0x80, /* 0011000010 */ + 0x7f, 0x80, /* 0111111110 */ + 0x7f, 0x80, /* 0111111110 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 254 0xfe '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x3f, 0x00, /* 0011111100 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + + /* 255 0xff '.' */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + 0x00, 0x00, /* 0000000000 */ + +}; diff --git a/kernel/graphics/fonts/font_6x10.h b/kernel/graphics/fonts/font_6x10.h new file mode 100644 index 0000000..69faa5a --- /dev/null +++ b/kernel/graphics/fonts/font_6x10.h @@ -0,0 +1,3077 @@ + +// SPDX-License-Identifier: GPL-2.0 +static const unsigned char fontdata_6x10[] = { + + /* 0 0x00 '^@' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 1 0x01 '^A' */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x84, /* 10000100 */ + 0xCC, /* 11001100 */ + 0x84, /* 10000100 */ + 0xCC, /* 11001100 */ + 0xB4, /* 10110100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 2 0x02 '^B' */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0xFC, /* 11111100 */ + 0xB4, /* 10110100 */ + 0xFC, /* 11111100 */ + 0xB4, /* 10110100 */ + 0xCC, /* 11001100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 3 0x03 '^C' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x7C, /* 01111100 */ + 0x7C, /* 01111100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 4 0x04 '^D' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x7C, /* 01111100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 5 0x05 '^E' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x6C, /* 01101100 */ + 0x6C, /* 01101100 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 6 0x06 '^F' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x7C, /* 01111100 */ + 0x7C, /* 01111100 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 7 0x07 '^G' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x78, /* 01111000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 8 0x08 '^H' */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xCC, /* 11001100 */ + 0x84, /* 10000100 */ + 0xCC, /* 11001100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + + /* 9 0x09 '^I' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x48, /* 01001000 */ + 0x84, /* 10000100 */ + 0x48, /* 01001000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 10 0x0A '^J' */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xCC, /* 11001100 */ + 0xB4, /* 10110100 */ + 0x78, /* 01111000 */ + 0xB4, /* 10110100 */ + 0xCC, /* 11001100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + + /* 11 0x0B '^K' */ + 0x00, /* 00000000 */ + 0x3C, /* 00111100 */ + 0x14, /* 00010100 */ + 0x20, /* 00100000 */ + 0x78, /* 01111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 12 0x0C '^L' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 13 0x0D '^M' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x14, /* 00010100 */ + 0x14, /* 00010100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x70, /* 01110000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 14 0x0E '^N' */ + 0x00, /* 00000000 */ + 0x3C, /* 00111100 */ + 0x24, /* 00100100 */ + 0x3C, /* 00111100 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x6C, /* 01101100 */ + 0x6C, /* 01101100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 15 0x0F '^O' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x6C, /* 01101100 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 16 0x10 '^P' */ + 0x00, /* 00000000 */ + 0x40, /* 01000000 */ + 0x60, /* 01100000 */ + 0x70, /* 01110000 */ + 0x78, /* 01111000 */ + 0x70, /* 01110000 */ + 0x60, /* 01100000 */ + 0x40, /* 01000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 17 0x11 '^Q' */ + 0x00, /* 00000000 */ + 0x04, /* 00000100 */ + 0x0C, /* 00001100 */ + 0x1C, /* 00011100 */ + 0x3C, /* 00111100 */ + 0x1C, /* 00011100 */ + 0x0C, /* 00001100 */ + 0x04, /* 00000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 18 0x12 '^R' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x10, /* 00010000 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 19 0x13 '^S' */ + 0x00, /* 00000000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x00, /* 00000000 */ + 0x48, /* 01001000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 20 0x14 '^T' */ + 0x3C, /* 00111100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x3C, /* 00111100 */ + 0x14, /* 00010100 */ + 0x14, /* 00010100 */ + 0x14, /* 00010100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 21 0x15 '^U' */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x20, /* 00100000 */ + 0x50, /* 01010000 */ + 0x48, /* 01001000 */ + 0x24, /* 00100100 */ + 0x14, /* 00010100 */ + 0x08, /* 00001000 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + + /* 22 0x16 '^V' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xF8, /* 11111000 */ + 0xF8, /* 11111000 */ + 0xF8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 23 0x17 '^W' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x10, /* 00010000 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 24 0x18 '^X' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 25 0x19 '^Y' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 26 0x1A '^Z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x7C, /* 01111100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 27 0x1B '^[' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x7C, /* 01111100 */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 28 0x1C '^\' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 29 0x1D '^]' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x48, /* 01001000 */ + 0x84, /* 10000100 */ + 0xFC, /* 11111100 */ + 0x84, /* 10000100 */ + 0x48, /* 01001000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 30 0x1E '^^' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x7C, /* 01111100 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 31 0x1F '^_' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x7C, /* 01111100 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 32 0x20 ' ' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 33 0x21 '!' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 34 0x22 '"' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 35 0x23 '#' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x7C, /* 01111100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x7C, /* 01111100 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 36 0x24 '$' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x50, /* 01010000 */ + 0x38, /* 00111000 */ + 0x14, /* 00010100 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + + /* 37 0x25 '%' */ + 0x00, /* 00000000 */ + 0x64, /* 01100100 */ + 0x64, /* 01100100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x4C, /* 01001100 */ + 0x4C, /* 01001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 38 0x26 '&' */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x48, /* 01001000 */ + 0x50, /* 01010000 */ + 0x20, /* 00100000 */ + 0x54, /* 01010100 */ + 0x48, /* 01001000 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 39 0x27 ''' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 40 0x28 '(' */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x20, /* 00100000 */ + 0x20, /* 00100000 */ + 0x20, /* 00100000 */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + + /* 41 0x29 ')' */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x00, /* 00000000 */ + + /* 42 0x2A '*' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 43 0x2B '+' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x7C, /* 01111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 44 0x2C ',' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + + /* 45 0x2D '-' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 46 0x2E '.' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 47 0x2F '/' */ + 0x04, /* 00000100 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x20, /* 00100000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + + /* 48 0x30 '0' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x54, /* 01010100 */ + 0x64, /* 01100100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 49 0x31 '1' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x30, /* 00110000 */ + 0x50, /* 01010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 50 0x32 '2' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 51 0x33 '3' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x04, /* 00000100 */ + 0x18, /* 00011000 */ + 0x04, /* 00000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 52 0x34 '4' */ + 0x00, /* 00000000 */ + 0x08, /* 00001000 */ + 0x18, /* 00011000 */ + 0x28, /* 00101000 */ + 0x48, /* 01001000 */ + 0x7C, /* 01111100 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 53 0x35 '5' */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x78, /* 01111000 */ + 0x04, /* 00000100 */ + 0x04, /* 00000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 54 0x36 '6' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x20, /* 00100000 */ + 0x40, /* 01000000 */ + 0x78, /* 01111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 55 0x37 '7' */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x04, /* 00000100 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 56 0x38 '8' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 57 0x39 '9' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 58 0x3A ':' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 59 0x3B ';' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + + /* 60 0x3C '<' */ + 0x00, /* 00000000 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x04, /* 00000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 61 0x3D '=' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 62 0x3E '>' */ + 0x00, /* 00000000 */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 63 0x3F '?' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 64 0x40 '@' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x5C, /* 01011100 */ + 0x54, /* 01010100 */ + 0x5C, /* 01011100 */ + 0x40, /* 01000000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 65 0x41 'A' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 66 0x42 'B' */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x38, /* 00111000 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 67 0x43 'C' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 68 0x44 'D' */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 69 0x45 'E' */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x78, /* 01111000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 70 0x46 'F' */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x78, /* 01111000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 71 0x47 'G' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x40, /* 01000000 */ + 0x5C, /* 01011100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 72 0x48 'H' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 73 0x49 'I' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 74 0x4A 'J' */ + 0x00, /* 00000000 */ + 0x1C, /* 00011100 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 75 0x4B 'K' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x48, /* 01001000 */ + 0x50, /* 01010000 */ + 0x60, /* 01100000 */ + 0x50, /* 01010000 */ + 0x48, /* 01001000 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 76 0x4C 'L' */ + 0x00, /* 00000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 77 0x4D 'M' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x6C, /* 01101100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 78 0x4E 'N' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x64, /* 01100100 */ + 0x54, /* 01010100 */ + 0x4C, /* 01001100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 79 0x4F 'O' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 80 0x50 'P' */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x78, /* 01111000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 81 0x51 'Q' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x54, /* 01010100 */ + 0x48, /* 01001000 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 82 0x52 'R' */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x78, /* 01111000 */ + 0x50, /* 01010000 */ + 0x48, /* 01001000 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 83 0x53 'S' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x40, /* 01000000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 84 0x54 'T' */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 85 0x55 'U' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 86 0x56 'V' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x28, /* 00101000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 87 0x57 'W' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x6C, /* 01101100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 88 0x58 'X' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x28, /* 00101000 */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 89 0x59 'Y' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x28, /* 00101000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 90 0x5A 'Z' */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x40, /* 01000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 91 0x5B '[' */ + 0x18, /* 00011000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 92 0x5C '\' */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x20, /* 00100000 */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x04, /* 00000100 */ + 0x04, /* 00000100 */ + + /* 93 0x5D ']' */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + + /* 94 0x5E '^' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 95 0x5F '_' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 96 0x60 '`' */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 97 0x61 'a' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x3C, /* 00111100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 98 0x62 'b' */ + 0x00, /* 00000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x58, /* 01011000 */ + 0x64, /* 01100100 */ + 0x44, /* 01000100 */ + 0x64, /* 01100100 */ + 0x58, /* 01011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 99 0x63 'c' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x40, /* 01000000 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 100 0x64 'd' */ + 0x00, /* 00000000 */ + 0x04, /* 00000100 */ + 0x04, /* 00000100 */ + 0x34, /* 00110100 */ + 0x4C, /* 01001100 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 101 0x65 'e' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 102 0x66 'f' */ + 0x00, /* 00000000 */ + 0x0C, /* 00001100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 103 0x67 'g' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x34, /* 00110100 */ + 0x4C, /* 01001100 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x34, /* 00110100 */ + 0x04, /* 00000100 */ + 0x38, /* 00111000 */ + + /* 104 0x68 'h' */ + 0x00, /* 00000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x78, /* 01111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 105 0x69 'i' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 106 0x6A 'j' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x60, /* 01100000 */ + + /* 107 0x6B 'k' */ + 0x00, /* 00000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x48, /* 01001000 */ + 0x50, /* 01010000 */ + 0x70, /* 01110000 */ + 0x48, /* 01001000 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 108 0x6C 'l' */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 109 0x6D 'm' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x68, /* 01101000 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 110 0x6E 'n' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x58, /* 01011000 */ + 0x64, /* 01100100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 111 0x6F 'o' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 112 0x70 'p' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x58, /* 01011000 */ + 0x64, /* 01100100 */ + 0x44, /* 01000100 */ + 0x64, /* 01100100 */ + 0x58, /* 01011000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + + /* 113 0x71 'q' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x34, /* 00110100 */ + 0x4C, /* 01001100 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x34, /* 00110100 */ + 0x04, /* 00000100 */ + 0x04, /* 00000100 */ + + /* 114 0x72 'r' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x58, /* 01011000 */ + 0x64, /* 01100100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 115 0x73 's' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3C, /* 00111100 */ + 0x40, /* 01000000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 116 0x74 't' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x0C, /* 00001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 117 0x75 'u' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 118 0x76 'v' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x28, /* 00101000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 119 0x77 'w' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 120 0x78 'x' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x28, /* 00101000 */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 121 0x79 'y' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x04, /* 00000100 */ + 0x38, /* 00111000 */ + + /* 122 0x7A 'z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 123 0x7B '{' */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + + /* 124 0x7C '|' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + + /* 125 0x7D '}' */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x00, /* 00000000 */ + + /* 126 0x7E '~' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x20, /* 00100000 */ + 0x54, /* 01010100 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 127 0x7F '' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 128 0x80 '\200' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + + /* 129 0x81 '\201' */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 130 0x82 '\202' */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 131 0x83 '\203' */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x3C, /* 00111100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 132 0x84 '\204' */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x3C, /* 00111100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 133 0x85 '\205' */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x3C, /* 00111100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 134 0x86 '\206' */ + 0x18, /* 00011000 */ + 0x24, /* 00100100 */ + 0x18, /* 00011000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x3C, /* 00111100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 135 0x87 '\207' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x40, /* 01000000 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + + /* 136 0x88 '\210' */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 137 0x89 '\211' */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 138 0x8A '\212' */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 139 0x8B '\213' */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 140 0x8C '\214' */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 141 0x8D '\215' */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 142 0x8E '\216' */ + 0x44, /* 01000100 */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 143 0x8F '\217' */ + 0x30, /* 00110000 */ + 0x48, /* 01001000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 144 0x90 '\220' */ + 0x10, /* 00010000 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x78, /* 01111000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 145 0x91 '\221' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x14, /* 00010100 */ + 0x7C, /* 01111100 */ + 0x50, /* 01010000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 146 0x92 '\222' */ + 0x00, /* 00000000 */ + 0x3C, /* 00111100 */ + 0x50, /* 01010000 */ + 0x50, /* 01010000 */ + 0x78, /* 01111000 */ + 0x50, /* 01010000 */ + 0x50, /* 01010000 */ + 0x5C, /* 01011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 147 0x93 '\223' */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 148 0x94 '\224' */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 149 0x95 '\225' */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 150 0x96 '\226' */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 151 0x97 '\227' */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 152 0x98 '\230' */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x04, /* 00000100 */ + 0x38, /* 00111000 */ + + /* 153 0x99 '\231' */ + 0x84, /* 10000100 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 154 0x9A '\232' */ + 0x88, /* 10001000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 155 0x9B '\233' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x50, /* 01010000 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + + /* 156 0x9C '\234' */ + 0x30, /* 00110000 */ + 0x48, /* 01001000 */ + 0x40, /* 01000000 */ + 0x70, /* 01110000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x44, /* 01000100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 157 0x9D '\235' */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x28, /* 00101000 */ + 0x7C, /* 01111100 */ + 0x10, /* 00010000 */ + 0x7C, /* 01111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 158 0x9E '\236' */ + 0x00, /* 00000000 */ + 0x70, /* 01110000 */ + 0x48, /* 01001000 */ + 0x70, /* 01110000 */ + 0x48, /* 01001000 */ + 0x5C, /* 01011100 */ + 0x48, /* 01001000 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 159 0x9F '\237' */ + 0x00, /* 00000000 */ + 0x0C, /* 00001100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 160 0xA0 '\240' */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x3C, /* 00111100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 161 0xA1 '\241' */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 162 0xA2 '\242' */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 163 0xA3 '\243' */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x4C, /* 01001100 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 164 0xA4 '\244' */ + 0x34, /* 00110100 */ + 0x58, /* 01011000 */ + 0x00, /* 00000000 */ + 0x58, /* 01011000 */ + 0x64, /* 01100100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 165 0xA5 '\245' */ + 0x58, /* 01011000 */ + 0x44, /* 01000100 */ + 0x64, /* 01100100 */ + 0x54, /* 01010100 */ + 0x4C, /* 01001100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 166 0xA6 '\246' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x04, /* 00000100 */ + 0x3C, /* 00111100 */ + 0x44, /* 01000100 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 167 0xA7 '\247' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 168 0xA8 '\250' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x40, /* 01000000 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 169 0xA9 '\251' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 170 0xAA '\252' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x04, /* 00000100 */ + 0x04, /* 00000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 171 0xAB '\253' */ + 0x20, /* 00100000 */ + 0x60, /* 01100000 */ + 0x24, /* 00100100 */ + 0x28, /* 00101000 */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x44, /* 01000100 */ + 0x08, /* 00001000 */ + 0x1C, /* 00011100 */ + 0x00, /* 00000000 */ + + /* 172 0xAC '\254' */ + 0x20, /* 00100000 */ + 0x60, /* 01100000 */ + 0x24, /* 00100100 */ + 0x28, /* 00101000 */ + 0x10, /* 00010000 */ + 0x28, /* 00101000 */ + 0x58, /* 01011000 */ + 0x3C, /* 00111100 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + + /* 173 0xAD '\255' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 174 0xAE '\256' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x24, /* 00100100 */ + 0x48, /* 01001000 */ + 0x90, /* 10010000 */ + 0x48, /* 01001000 */ + 0x24, /* 00100100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 175 0xAF '\257' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x90, /* 10010000 */ + 0x48, /* 01001000 */ + 0x24, /* 00100100 */ + 0x48, /* 01001000 */ + 0x90, /* 10010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 176 0xB0 '\260' */ + 0x10, /* 00010000 */ + 0x44, /* 01000100 */ + 0x10, /* 00010000 */ + 0x44, /* 01000100 */ + 0x10, /* 00010000 */ + 0x44, /* 01000100 */ + 0x10, /* 00010000 */ + 0x44, /* 01000100 */ + 0x10, /* 00010000 */ + 0x44, /* 01000100 */ + + /* 177 0xB1 '\261' */ + 0xA8, /* 10101000 */ + 0x54, /* 01010100 */ + 0xA8, /* 10101000 */ + 0x54, /* 01010100 */ + 0xA8, /* 10101000 */ + 0x54, /* 01010100 */ + 0xA8, /* 10101000 */ + 0x54, /* 01010100 */ + 0xA8, /* 10101000 */ + 0x54, /* 01010100 */ + + /* 178 0xB2 '\262' */ + 0xDC, /* 11011100 */ + 0x74, /* 01110100 */ + 0xDC, /* 11011100 */ + 0x74, /* 01110100 */ + 0xDC, /* 11011100 */ + 0x74, /* 01110100 */ + 0xDC, /* 11011100 */ + 0x74, /* 01110100 */ + 0xDC, /* 11011100 */ + 0x74, /* 01110100 */ + + /* 179 0xB3 '\263' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 180 0xB4 '\264' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0xF0, /* 11110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 181 0xB5 '\265' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0xF0, /* 11110000 */ + 0x10, /* 00010000 */ + 0xF0, /* 11110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 182 0xB6 '\266' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0xE8, /* 11101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 183 0xB7 '\267' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xF8, /* 11111000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 184 0xB8 '\270' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xF0, /* 11110000 */ + 0x10, /* 00010000 */ + 0xF0, /* 11110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 185 0xB9 '\271' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0xE8, /* 11101000 */ + 0x08, /* 00001000 */ + 0xE8, /* 11101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 186 0xBA '\272' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 187 0xBB '\273' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xF8, /* 11111000 */ + 0x08, /* 00001000 */ + 0xE8, /* 11101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 188 0xBC '\274' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0xE8, /* 11101000 */ + 0x08, /* 00001000 */ + 0xF8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 189 0xBD '\275' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0xF8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 190 0xBE '\276' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0xF0, /* 11110000 */ + 0x10, /* 00010000 */ + 0xF0, /* 11110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 191 0xBF '\277' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xF0, /* 11110000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 192 0xC0 '\300' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x1C, /* 00011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 193 0xC1 '\301' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 194 0xC2 '\302' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 195 0xC3 '\303' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x1C, /* 00011100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 196 0xC4 '\304' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 197 0xC5 '\305' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0xFC, /* 11111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 198 0xC6 '\306' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x1C, /* 00011100 */ + 0x10, /* 00010000 */ + 0x1C, /* 00011100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 199 0xC7 '\307' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x2C, /* 00101100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 200 0xC8 '\310' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x2C, /* 00101100 */ + 0x20, /* 00100000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 201 0xC9 '\311' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3C, /* 00111100 */ + 0x20, /* 00100000 */ + 0x2C, /* 00101100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 202 0xCA '\312' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0xEC, /* 11101100 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 203 0xCB '\313' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0xEC, /* 11101100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 204 0xCC '\314' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x2C, /* 00101100 */ + 0x20, /* 00100000 */ + 0x2C, /* 00101100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 205 0xCD '\315' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 206 0xCE '\316' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0xEC, /* 11101100 */ + 0x00, /* 00000000 */ + 0xEC, /* 11101100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 207 0xCF '\317' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 208 0xD0 '\320' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 209 0xD1 '\321' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 210 0xD2 '\322' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 211 0xD3 '\323' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 212 0xD4 '\324' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x1C, /* 00011100 */ + 0x10, /* 00010000 */ + 0x1C, /* 00011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 213 0xD5 '\325' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1C, /* 00011100 */ + 0x10, /* 00010000 */ + 0x1C, /* 00011100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 214 0xD6 '\326' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3C, /* 00111100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 215 0xD7 '\327' */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0xFC, /* 11111100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + + /* 216 0xD8 '\330' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0xFC, /* 11111100 */ + 0x10, /* 00010000 */ + 0xFC, /* 11111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 217 0xD9 '\331' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0xF0, /* 11110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 218 0xDA '\332' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1C, /* 00011100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 219 0xDB '\333' */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + + /* 220 0xDC '\334' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + + /* 221 0xDD '\335' */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + 0xE0, /* 11100000 */ + + /* 222 0xDE '\336' */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + 0x1C, /* 00011100 */ + + /* 223 0xDF '\337' */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 224 0xE0 '\340' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x34, /* 00110100 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x34, /* 00110100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 225 0xE1 '\341' */ + 0x18, /* 00011000 */ + 0x24, /* 00100100 */ + 0x44, /* 01000100 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x58, /* 01011000 */ + 0x40, /* 01000000 */ + 0x00, /* 00000000 */ + + /* 226 0xE2 '\342' */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 227 0xE3 '\343' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 228 0xE4 '\344' */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x24, /* 00100100 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x24, /* 00100100 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 229 0xE5 '\345' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3C, /* 00111100 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 230 0xE6 '\346' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x74, /* 01110100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + + /* 231 0xE7 '\347' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x0C, /* 00001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 232 0xE8 '\350' */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 233 0xE9 '\351' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x7C, /* 01111100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 234 0xEA '\352' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x28, /* 00101000 */ + 0x6C, /* 01101100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 235 0xEB '\353' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x20, /* 00100000 */ + 0x18, /* 00011000 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x24, /* 00100100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 236 0xEC '\354' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 237 0xED '\355' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x04, /* 00000100 */ + 0x38, /* 00111000 */ + 0x54, /* 01010100 */ + 0x54, /* 01010100 */ + 0x38, /* 00111000 */ + 0x40, /* 01000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 238 0xEE '\356' */ + 0x00, /* 00000000 */ + 0x3C, /* 00111100 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x38, /* 00111000 */ + 0x40, /* 01000000 */ + 0x40, /* 01000000 */ + 0x3C, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 239 0xEF '\357' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x44, /* 01000100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 240 0xF0 '\360' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0xFC, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 241 0xF1 '\361' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x7C, /* 01111100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 242 0xF2 '\362' */ + 0x00, /* 00000000 */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 243 0xF3 '\363' */ + 0x00, /* 00000000 */ + 0x08, /* 00001000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x10, /* 00010000 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 244 0xF4 '\364' */ + 0x00, /* 00000000 */ + 0x0C, /* 00001100 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + + /* 245 0xF5 '\365' */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x10, /* 00010000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + + /* 246 0xF6 '\366' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x7C, /* 01111100 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 247 0xF7 '\367' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x20, /* 00100000 */ + 0x54, /* 01010100 */ + 0x08, /* 00001000 */ + 0x20, /* 00100000 */ + 0x54, /* 01010100 */ + 0x08, /* 00001000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 248 0xF8 '\370' */ + 0x30, /* 00110000 */ + 0x48, /* 01001000 */ + 0x48, /* 01001000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 249 0xF9 '\371' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 250 0xFA '\372' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 251 0xFB '\373' */ + 0x00, /* 00000000 */ + 0x04, /* 00000100 */ + 0x08, /* 00001000 */ + 0x08, /* 00001000 */ + 0x50, /* 01010000 */ + 0x50, /* 01010000 */ + 0x20, /* 00100000 */ + 0x20, /* 00100000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 252 0xFC '\374' */ + 0x60, /* 01100000 */ + 0x50, /* 01010000 */ + 0x50, /* 01010000 */ + 0x50, /* 01010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 253 0xFD '\375' */ + 0x60, /* 01100000 */ + 0x10, /* 00010000 */ + 0x20, /* 00100000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 254 0xFE '\376' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 255 0xFF '\377' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + +}; diff --git a/kernel/graphics/fonts/font_6x11.h b/kernel/graphics/fonts/font_6x11.h new file mode 100644 index 0000000..a99bf31 --- /dev/null +++ b/kernel/graphics/fonts/font_6x11.h @@ -0,0 +1,3339 @@ + +// SPDX-License-Identifier: GPL-2.0 +/**********************************************/ +/* */ +/* Font file generated by rthelen */ +/* */ +/**********************************************/ + +static const unsigned char fontdata_6x11[] = { + + /* 0 0x00 '^@' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 1 0x01 '^A' */ + 0x00, /* 00000000 */ + 0x78, /* 0 000 */ + 0x84, /* 0000 00 */ + 0xcc, /* 00 00 */ + 0x84, /* 0000 00 */ + 0xb4, /* 0 0 00 */ + 0x84, /* 0000 00 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 2 0x02 '^B' */ + 0x00, /* 00000000 */ + 0x78, /* 0 000 */ + 0xfc, /* 00 */ + 0xb4, /* 0 0 00 */ + 0xfc, /* 00 */ + 0xcc, /* 00 00 */ + 0xfc, /* 00 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 3 0x03 '^C' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x28, /* 00 0 000 */ + 0x7c, /* 0 00 */ + 0x7c, /* 0 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 4 0x04 '^D' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x7c, /* 0 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 5 0x05 '^E' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x38, /* 00 000 */ + 0x6c, /* 0 0 00 */ + 0x6c, /* 0 0 00 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 6 0x06 '^F' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x7c, /* 0 00 */ + 0x7c, /* 0 00 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 7 0x07 '^G' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x78, /* 0 000 */ + 0x30, /* 00 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 8 0x08 '^H' */ + 0xff, /* */ + 0xff, /* */ + 0xff, /* */ + 0xcf, /* 00 */ + 0x87, /* 0000 */ + 0xcf, /* 00 */ + 0xff, /* */ + 0xff, /* */ + 0xff, /* */ + 0xff, /* */ + 0xff, /* */ + + /* 9 0x09 '^I' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x48, /* 0 00 000 */ + 0x84, /* 0000 00 */ + 0x48, /* 0 00 000 */ + 0x30, /* 00 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 10 0x0a '^J' */ + 0xff, /* */ + 0xff, /* */ + 0xcf, /* 00 */ + 0xb7, /* 0 0 */ + 0x7b, /* 0 0 */ + 0xb7, /* 0 0 */ + 0xcf, /* 00 */ + 0xff, /* */ + 0xff, /* */ + 0xff, /* */ + 0xff, /* */ + + /* 11 0x0b '^K' */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x14, /* 000 0 00 */ + 0x20, /* 00 00000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 12 0x0c '^L' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x7c, /* 0 00 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 13 0x0d '^M' */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x24, /* 00 00 00 */ + 0x3c, /* 00 00 */ + 0x20, /* 00 00000 */ + 0x20, /* 00 00000 */ + 0xe0, /* 00000 */ + 0xc0, /* 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 14 0x0e '^N' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0xcc, /* 00 00 */ + 0xcc, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 15 0x0f '^O' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x6c, /* 0 0 00 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 16 0x10 '^P' */ + 0x00, /* 00000000 */ + 0x40, /* 0 000000 */ + 0x60, /* 0 00000 */ + 0x70, /* 0 0000 */ + 0x7c, /* 0 00 */ + 0x70, /* 0 0000 */ + 0x60, /* 0 00000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 17 0x11 '^Q' */ + 0x00, /* 00000000 */ + 0x04, /* 00000 00 */ + 0x0c, /* 0000 00 */ + 0x1c, /* 000 00 */ + 0x7c, /* 0 00 */ + 0x1c, /* 000 00 */ + 0x0c, /* 0000 00 */ + 0x04, /* 00000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 18 0x12 '^R' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x10, /* 000 0000 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 19 0x13 '^S' */ + 0x00, /* 00000000 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x00, /* 00000000 */ + 0x48, /* 0 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 20 0x14 '^T' */ + 0x3c, /* 00 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x3c, /* 00 00 */ + 0x14, /* 000 0 00 */ + 0x14, /* 000 0 00 */ + 0x14, /* 000 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 21 0x15 '^U' */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x24, /* 00 00 00 */ + 0x50, /* 0 0 0000 */ + 0x48, /* 0 00 000 */ + 0x24, /* 00 00 00 */ + 0x14, /* 000 0 00 */ + 0x48, /* 0 00 000 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + + /* 22 0x16 '^V' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 000 */ + 0xf8, /* 000 */ + 0xf8, /* 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 23 0x17 '^W' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x10, /* 000 0000 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 24 0x18 '^X' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 25 0x19 '^Y' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 26 0x1a '^Z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x7c, /* 0 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 27 0x1b '^[' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x7c, /* 0 00 */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 28 0x1c '^\' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 29 0x1d '^]' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x48, /* 0 00 000 */ + 0x84, /* 0000 00 */ + 0xfc, /* 00 */ + 0x84, /* 0000 00 */ + 0x48, /* 0 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 30 0x1e '^^' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x38, /* 00 000 */ + 0x7c, /* 0 00 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 31 0x1f '^`' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x7c, /* 0 00 */ + 0x38, /* 00 000 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 32 0x20 ' ' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 33 0x21 '!' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 34 0x22 '"' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 35 0x23 '#' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x28, /* 00 0 000 */ + 0x7c, /* 0 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x7c, /* 0 00 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 36 0x24 '$' */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x50, /* 0 0 0000 */ + 0x38, /* 00 000 */ + 0x14, /* 000 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 37 0x25 '%' */ + 0x00, /* 00000000 */ + 0x64, /* 0 00 00 */ + 0x64, /* 0 00 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x4c, /* 0 00 00 */ + 0x4c, /* 0 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 38 0x26 '&' */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x48, /* 0 00 000 */ + 0x50, /* 0 0 0000 */ + 0x20, /* 00 00000 */ + 0x54, /* 0 0 0 00 */ + 0x48, /* 0 00 000 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 39 0x27 ''' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 40 0x28 '(' */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x04, /* 00000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 41 0x29 ')' */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 42 0x2a '*' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 43 0x2b '+' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x7c, /* 0 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 44 0x2c ',' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x30, /* 00 0000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x00, /* 00000000 */ + + /* 45 0x2d '-' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 46 0x2e '.' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 000 000 */ + 0x18, /* 000 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 47 0x2f '/' */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x20, /* 00 00000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + + /* 48 0x30 '0' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x54, /* 0 0 0 00 */ + 0x64, /* 0 00 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 49 0x31 '1' */ + 0x00, /* 00000000 */ + 0x08, /* 0000 000 */ + 0x18, /* 000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x1c, /* 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 50 0x32 '2' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 51 0x33 '3' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x04, /* 00000 00 */ + 0x18, /* 000 000 */ + 0x04, /* 00000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 52 0x34 '4' */ + 0x00, /* 00000000 */ + 0x08, /* 0000 000 */ + 0x18, /* 000 000 */ + 0x28, /* 00 0 000 */ + 0x48, /* 0 00 000 */ + 0x7c, /* 0 00 */ + 0x08, /* 0000 000 */ + 0x1c, /* 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 53 0x35 '5' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 54 0x36 '6' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 55 0x37 '7' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 56 0x38 '8' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 57 0x39 '9' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x3c, /* 00 00 */ + 0x04, /* 00000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 58 0x3a ':' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 000 000 */ + 0x18, /* 000 000 */ + 0x00, /* 00000000 */ + 0x18, /* 000 000 */ + 0x18, /* 000 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 59 0x3b ';' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x30, /* 00 0000 */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x30, /* 00 0000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x00, /* 00000000 */ + + /* 60 0x3c '<' */ + 0x00, /* 00000000 */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x04, /* 00000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 61 0x3d '=' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 62 0x3e '>' */ + 0x00, /* 00000000 */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 63 0x3f '?' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 64 0x40 '@' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x74, /* 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x78, /* 0 000 */ + 0x40, /* 0 000000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 65 0x41 'A' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 66 0x42 'B' */ + 0x00, /* 00000000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 67 0x43 'C' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 68 0x44 'D' */ + 0x00, /* 00000000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 69 0x45 'E' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 70 0x46 'F' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 71 0x47 'G' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x40, /* 0 000000 */ + 0x4c, /* 0 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 72 0x48 'H' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 73 0x49 'I' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 74 0x4a 'J' */ + 0x00, /* 00000000 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 75 0x4b 'K' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x48, /* 0 00 000 */ + 0x50, /* 0 0 0000 */ + 0x60, /* 0 00000 */ + 0x50, /* 0 0 0000 */ + 0x48, /* 0 00 000 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 76 0x4c 'L' */ + 0x00, /* 00000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 77 0x4d 'M' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x6c, /* 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 78 0x4e 'N' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x64, /* 0 00 00 */ + 0x54, /* 0 0 0 00 */ + 0x4c, /* 0 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 79 0x4f 'O' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 80 0x50 'P' */ + 0x00, /* 00000000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x78, /* 0 000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 81 0x51 'Q' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x04, /* 00000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 82 0x52 'R' */ + 0x00, /* 00000000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 83 0x53 'S' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x40, /* 0 000000 */ + 0x38, /* 00 000 */ + 0x04, /* 00000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 84 0x54 'T' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 85 0x55 'U' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 86 0x56 'V' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x28, /* 00 0 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 87 0x57 'W' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x6c, /* 0 0 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 88 0x58 'X' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x28, /* 00 0 000 */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 89 0x59 'Y' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x28, /* 00 0 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 90 0x5a 'Z' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x40, /* 0 000000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 91 0x5b '[' */ + 0x0c, /* 0000 00 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x0c, /* 0000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 92 0x5c '\' */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x20, /* 00 00000 */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x00, /* 00000000 */ + + /* 93 0x5d ']' */ + 0x30, /* 00 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x30, /* 00 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 94 0x5e '^' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 95 0x5f '_' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 96 0x60 '`' */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 97 0x61 'a' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 98 0x62 'b' */ + 0x00, /* 00000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 99 0x63 'c' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x40, /* 0 000000 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 100 0x64 'd' */ + 0x00, /* 00000000 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 101 0x65 'e' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 102 0x66 'f' */ + 0x00, /* 00000000 */ + 0x0c, /* 0000 00 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 103 0x67 'g' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x3c, /* 00 00 */ + 0x04, /* 00000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + + /* 104 0x68 'h' */ + 0x00, /* 00000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 105 0x69 'i' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 106 0x6a 'j' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x60, /* 0 00000 */ + 0x00, /* 00000000 */ + + /* 107 0x6b 'k' */ + 0x00, /* 00000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x48, /* 0 00 000 */ + 0x50, /* 0 0 0000 */ + 0x70, /* 0 0000 */ + 0x48, /* 0 00 000 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 108 0x6c 'l' */ + 0x00, /* 00000000 */ + 0x30, /* 00 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 109 0x6d 'm' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x78, /* 0 000 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 110 0x6e 'n' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x58, /* 0 0 000 */ + 0x64, /* 0 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 111 0x6f 'o' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 112 0x70 'p' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x78, /* 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x78, /* 0 000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + + /* 113 0x71 'q' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x3c, /* 00 00 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x00, /* 00000000 */ + + /* 114 0x72 'r' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x58, /* 0 0 000 */ + 0x64, /* 0 00 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 115 0x73 's' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x40, /* 0 000000 */ + 0x38, /* 00 000 */ + 0x04, /* 00000 00 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 116 0x74 't' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x0c, /* 0000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 117 0x75 'u' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 118 0x76 'v' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x28, /* 00 0 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 119 0x77 'w' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 120 0x78 'x' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x28, /* 00 0 000 */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 121 0x79 'y' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x3c, /* 00 00 */ + 0x04, /* 00000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + + /* 122 0x7a 'z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 123 0x7b '{' */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x04, /* 00000 00 */ + + /* 124 0x7c '|' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 125 0x7d '}' */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + + /* 126 0x7e '~' */ + 0x00, /* 00000000 */ + 0x34, /* 00 0 00 */ + 0x58, /* 0 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 127 0x7f '^?' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 128 0x80 '\200' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x00, /* 00000000 */ + + /* 129 0x81 '\201' */ + 0x00, /* 00000000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 130 0x82 '\202' */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 131 0x83 '\203' */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 132 0x84 '\204' */ + 0x00, /* 00000000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 133 0x85 '\205' */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 134 0x86 '\206' */ + 0x18, /* 000 000 */ + 0x24, /* 00 00 00 */ + 0x18, /* 000 000 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 135 0x87 '\207' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x3c, /* 00 00 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x00, /* 00000000 */ + + /* 136 0x88 '\210' */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 137 0x89 '\211' */ + 0x00, /* 00000000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 138 0x8a '\212' */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 139 0x8b '\213' */ + 0x00, /* 00000000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 140 0x8c '\214' */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 141 0x8d '\215' */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 142 0x8e '\216' */ + 0x84, /* 0000 00 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 143 0x8f '\217' */ + 0x58, /* 0 0 000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x7c, /* 0 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 144 0x90 '\220' */ + 0x10, /* 000 0000 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 145 0x91 '\221' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x5c, /* 0 0 00 */ + 0x50, /* 0 0 0000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 146 0x92 '\222' */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x50, /* 0 0 0000 */ + 0x50, /* 0 0 0000 */ + 0x78, /* 0 000 */ + 0x50, /* 0 0 0000 */ + 0x50, /* 0 0 0000 */ + 0x5c, /* 0 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 147 0x93 '\223' */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 148 0x94 '\224' */ + 0x00, /* 00000000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 149 0x95 '\225' */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 150 0x96 '\226' */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 151 0x97 '\227' */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 152 0x98 '\230' */ + 0x00, /* 00000000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x3c, /* 00 00 */ + 0x04, /* 00000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + + /* 153 0x99 '\231' */ + 0x84, /* 0000 00 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 154 0x9a '\232' */ + 0x88, /* 000 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 155 0x9b '\233' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x50, /* 0 0 0000 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 156 0x9c '\234' */ + 0x30, /* 00 0000 */ + 0x48, /* 0 00 000 */ + 0x40, /* 0 000000 */ + 0x70, /* 0 0000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x44, /* 0 000 00 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 157 0x9d '\235' */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x28, /* 00 0 000 */ + 0x7c, /* 0 00 */ + 0x10, /* 000 0000 */ + 0x7c, /* 0 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 158 0x9e '\236' */ + 0x00, /* 00000000 */ + 0x70, /* 0 0000 */ + 0x48, /* 0 00 000 */ + 0x70, /* 0 0000 */ + 0x48, /* 0 00 000 */ + 0x5c, /* 0 0 00 */ + 0x48, /* 0 00 000 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 159 0x9f '\237' */ + 0x00, /* 00000000 */ + 0x0c, /* 0000 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x60, /* 0 00000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 160 0xa0 '\240' */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 161 0xa1 '\241' */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 162 0xa2 '\242' */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 163 0xa3 '\243' */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x4c, /* 0 00 00 */ + 0x34, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 164 0xa4 '\244' */ + 0x34, /* 00 0 00 */ + 0x58, /* 0 0 000 */ + 0x00, /* 00000000 */ + 0x58, /* 0 0 000 */ + 0x64, /* 0 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 165 0xa5 '\245' */ + 0x58, /* 0 0 000 */ + 0x44, /* 0 000 00 */ + 0x64, /* 0 00 00 */ + 0x54, /* 0 0 0 00 */ + 0x4c, /* 0 00 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 166 0xa6 '\246' */ + 0x00, /* 00000000 */ + 0x1c, /* 000 00 */ + 0x24, /* 00 00 00 */ + 0x24, /* 00 00 00 */ + 0x1c, /* 000 00 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 167 0xa7 '\247' */ + 0x00, /* 00000000 */ + 0x18, /* 000 000 */ + 0x24, /* 00 00 00 */ + 0x24, /* 00 00 00 */ + 0x18, /* 000 000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 168 0xa8 '\250' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x40, /* 0 000000 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 169 0xa9 '\251' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 170 0xaa '\252' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x04, /* 00000 00 */ + 0x04, /* 00000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 171 0xab '\253' */ + 0x20, /* 00 00000 */ + 0x60, /* 0 00000 */ + 0x24, /* 00 00 00 */ + 0x28, /* 00 0 000 */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x44, /* 0 000 00 */ + 0x08, /* 0000 000 */ + 0x1c, /* 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 172 0xac '\254' */ + 0x20, /* 00 00000 */ + 0x60, /* 0 00000 */ + 0x24, /* 00 00 00 */ + 0x28, /* 00 0 000 */ + 0x10, /* 000 0000 */ + 0x28, /* 00 0 000 */ + 0x58, /* 0 0 000 */ + 0x3c, /* 00 00 */ + 0x08, /* 0000 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 173 0xad '\255' */ + 0x00, /* 00000000 */ + 0x08, /* 0000 000 */ + 0x00, /* 00000000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x08, /* 0000 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 174 0xae '\256' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x24, /* 00 00 00 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x24, /* 00 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 175 0xaf '\257' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x48, /* 0 00 000 */ + 0x24, /* 00 00 00 */ + 0x24, /* 00 00 00 */ + 0x48, /* 0 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 176 0xb0 '\260' */ + 0x11, /* 000 000 */ + 0x44, /* 0 000 00 */ + 0x11, /* 000 000 */ + 0x44, /* 0 000 00 */ + 0x11, /* 000 000 */ + 0x44, /* 0 000 00 */ + 0x11, /* 000 000 */ + 0x44, /* 0 000 00 */ + 0x11, /* 000 000 */ + 0x44, /* 0 000 00 */ + 0x11, /* 000 000 */ + + /* 177 0xb1 '\261' */ + 0x55, /* 0 0 0 0 */ + 0xaa, /* 0 0 0 0 */ + 0x55, /* 0 0 0 0 */ + 0xaa, /* 0 0 0 0 */ + 0x55, /* 0 0 0 0 */ + 0xaa, /* 0 0 0 0 */ + 0x55, /* 0 0 0 0 */ + 0xaa, /* 0 0 0 0 */ + 0x55, /* 0 0 0 0 */ + 0xaa, /* 0 0 0 0 */ + 0x55, /* 0 0 0 0 */ + + /* 178 0xb2 '\262' */ + 0xdd, /* 0 0 */ + 0x77, /* 0 0 */ + 0xdd, /* 0 0 */ + 0x77, /* 0 0 */ + 0xdd, /* 0 0 */ + 0x77, /* 0 0 */ + 0xdd, /* 0 0 */ + 0x77, /* 0 0 */ + 0xdd, /* 0 0 */ + 0x77, /* 0 0 */ + 0xdd, /* 0 0 */ + + /* 179 0xb3 '\263' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 180 0xb4 '\264' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0xf0, /* 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 181 0xb5 '\265' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0xf0, /* 0000 */ + 0x10, /* 000 0000 */ + 0xf0, /* 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 182 0xb6 '\266' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0xe8, /* 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 183 0xb7 '\267' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 184 0xb8 '\270' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf0, /* 0000 */ + 0x10, /* 000 0000 */ + 0xf0, /* 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 185 0xb9 '\271' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0xe8, /* 0 000 */ + 0x08, /* 0000 000 */ + 0xe8, /* 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 186 0xba '\272' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 187 0xbb '\273' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 000 */ + 0x08, /* 0000 000 */ + 0xe8, /* 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 188 0xbc '\274' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0xe8, /* 0 000 */ + 0x08, /* 0000 000 */ + 0xf8, /* 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 189 0xbd '\275' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0xf8, /* 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 190 0xbe '\276' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0xf0, /* 0000 */ + 0x10, /* 000 0000 */ + 0xf0, /* 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 191 0xbf '\277' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf0, /* 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 192 0xc0 '\300' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x1c, /* 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 193 0xc1 '\301' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 194 0xc2 '\302' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 195 0xc3 '\303' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x1c, /* 000 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 196 0xc4 '\304' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 197 0xc5 '\305' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0xfc, /* 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 198 0xc6 '\306' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x1c, /* 000 00 */ + 0x10, /* 000 0000 */ + 0x1c, /* 000 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 199 0xc7 '\307' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x2c, /* 00 0 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 200 0xc8 '\310' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x2c, /* 00 0 00 */ + 0x20, /* 00 00000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 201 0xc9 '\311' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x20, /* 00 00000 */ + 0x2c, /* 00 0 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 202 0xca '\312' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0xec, /* 0 00 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 203 0xcb '\313' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0xec, /* 0 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 204 0xcc '\314' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x2c, /* 00 0 00 */ + 0x20, /* 00 00000 */ + 0x2c, /* 00 0 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 205 0xcd '\315' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 206 0xce '\316' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0xec, /* 0 00 */ + 0x00, /* 00000000 */ + 0xec, /* 0 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 207 0xcf '\317' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 208 0xd0 '\320' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 209 0xd1 '\321' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 210 0xd2 '\322' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 211 0xd3 '\323' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 212 0xd4 '\324' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x1c, /* 000 00 */ + 0x10, /* 000 0000 */ + 0x1c, /* 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 213 0xd5 '\325' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1c, /* 000 00 */ + 0x10, /* 000 0000 */ + 0x1c, /* 000 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 214 0xd6 '\326' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 215 0xd7 '\327' */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0xfc, /* 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + + /* 216 0xd8 '\330' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0xfc, /* 00 */ + 0x10, /* 000 0000 */ + 0xfc, /* 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 217 0xd9 '\331' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0xf0, /* 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 218 0xda '\332' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1f, /* 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 219 0xdb '\333' */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + + /* 220 0xdc '\334' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + + /* 221 0xdd '\335' */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + 0xe0, /* 00000 */ + + /* 222 0xde '\336' */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + 0x1c, /* 000 00 */ + + /* 223 0xdf '\337' */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 224 0xe0 '\340' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x24, /* 00 00 00 */ + 0x58, /* 0 0 000 */ + 0x50, /* 0 0 0000 */ + 0x54, /* 0 0 0 00 */ + 0x2c, /* 00 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 225 0xe1 '\341' */ + 0x18, /* 000 000 */ + 0x24, /* 00 00 00 */ + 0x44, /* 0 000 00 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x58, /* 0 0 000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 226 0xe2 '\342' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 227 0xe3 '\343' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 228 0xe4 '\344' */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x24, /* 00 00 00 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x24, /* 00 00 00 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 229 0xe5 '\345' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x30, /* 00 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 230 0xe6 '\346' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x48, /* 0 00 000 */ + 0x74, /* 0 0 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + + /* 231 0xe7 '\347' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x6c, /* 0 0 00 */ + 0x98, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 232 0xe8 '\350' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 233 0xe9 '\351' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x4c, /* 0 00 00 */ + 0x54, /* 0 0 0 00 */ + 0x64, /* 0 00 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 234 0xea '\352' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x28, /* 00 0 000 */ + 0x6c, /* 0 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 235 0xeb '\353' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x0c, /* 0000 00 */ + 0x14, /* 000 0 00 */ + 0x24, /* 00 00 00 */ + 0x24, /* 00 00 00 */ + 0x18, /* 000 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 236 0xec '\354' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x54, /* 0 0 0 00 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 237 0xed '\355' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x04, /* 00000 00 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x38, /* 00 000 */ + 0x40, /* 0 000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 238 0xee '\356' */ + 0x00, /* 00000000 */ + 0x3c, /* 00 00 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x78, /* 0 000 */ + 0x40, /* 0 000000 */ + 0x40, /* 0 000000 */ + 0x3c, /* 00 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 239 0xef '\357' */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x44, /* 0 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 240 0xf0 '\360' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0xfc, /* 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 241 0xf1 '\361' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x7c, /* 0 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 242 0xf2 '\362' */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x04, /* 00000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x1c, /* 000 00 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 243 0xf3 '\363' */ + 0x00, /* 00000000 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x20, /* 00 00000 */ + 0x10, /* 000 0000 */ + 0x08, /* 0000 000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 244 0xf4 '\364' */ + 0x00, /* 00000000 */ + 0x0c, /* 0000 00 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + + /* 245 0xf5 '\365' */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x10, /* 000 0000 */ + 0x60, /* 0 00000 */ + 0x00, /* 00000000 */ + + /* 246 0xf6 '\366' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x7c, /* 0 00 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 247 0xf7 '\367' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x34, /* 00 0 00 */ + 0x48, /* 0 00 000 */ + 0x00, /* 00000000 */ + 0x34, /* 00 0 00 */ + 0x48, /* 0 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 248 0xf8 '\370' */ + 0x18, /* 000 000 */ + 0x24, /* 00 00 00 */ + 0x24, /* 00 00 00 */ + 0x18, /* 000 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 249 0xf9 '\371' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x38, /* 00 000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 250 0xfa '\372' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 000 0000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 251 0xfb '\373' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x0c, /* 0000 00 */ + 0x08, /* 0000 000 */ + 0x10, /* 000 0000 */ + 0x50, /* 0 0 0000 */ + 0x20, /* 00 00000 */ + 0x20, /* 00 00000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 252 0xfc '\374' */ + 0x00, /* 00000000 */ + 0x50, /* 0 0 0000 */ + 0x28, /* 00 0 000 */ + 0x28, /* 00 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 253 0xfd '\375' */ + 0x00, /* 00000000 */ + 0x70, /* 0 0000 */ + 0x08, /* 0000 000 */ + 0x20, /* 00 00000 */ + 0x78, /* 0 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 254 0xfe '\376' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00 000 */ + 0x38, /* 00 000 */ + 0x38, /* 00 000 */ + 0x38, /* 00 000 */ + 0x38, /* 00 000 */ + 0x38, /* 00 000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 255 0xff '\377' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + +}; diff --git a/kernel/graphics/fonts/font_7x14.h b/kernel/graphics/fonts/font_7x14.h new file mode 100644 index 0000000..51673a2 --- /dev/null +++ b/kernel/graphics/fonts/font_7x14.h @@ -0,0 +1,4106 @@ + +// SPDX-License-Identifier: GPL-2.0 +/**************************************/ +/* this file adapted from font_8x16.c */ +/* by Jurriaan Kalkman 05-2005 */ +/**************************************/ + +static const unsigned char fontdata_7x14[] = { + + /* 0 0x00 '^@' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 1 0x01 '^A' */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0x82, /* 1000001 */ + 0xaa, /* 1010101 */ + 0x82, /* 1000001 */ + 0x82, /* 1000001 */ + 0xba, /* 1011101 */ + 0x92, /* 1001001 */ + 0x82, /* 1000001 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 2 0x02 '^B' */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0xfe, /* 1111111 */ + 0xd6, /* 1101011 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xc6, /* 1100011 */ + 0xee, /* 1110111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 3 0x03 '^C' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x6c, /* 0110110 */ + 0x7c, /* 0111110 */ + 0xfe, /* 1111111 */ + 0x7c, /* 0111110 */ + 0x38, /* 0011100 */ + 0x18, /* 0001100 */ + 0x10, /* 0001000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 4 0x04 '^D' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x7c, /* 0111110 */ + 0xfe, /* 1111111 */ + 0x7c, /* 0111110 */ + 0x38, /* 0011100 */ + 0x10, /* 0001000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 5 0x05 '^E' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x38, /* 0011100 */ + 0x38, /* 0011100 */ + 0xee, /* 1110111 */ + 0xee, /* 1110111 */ + 0xee, /* 1110111 */ + 0x10, /* 0001000 */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 6 0x06 '^F' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x7c, /* 0111110 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0x7c, /* 0111110 */ + 0x10, /* 0001000 */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 7 0x07 '^G' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x3c, /* 0011110 */ + 0x3c, /* 0011110 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 8 0x08 '^H' */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xe6, /* 1110011 */ + 0xc2, /* 1100001 */ + 0xc2, /* 1100001 */ + 0xe6, /* 1110011 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + + /* 9 0x09 '^I' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x44, /* 0100010 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 10 0x0a '^J' */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xc6, /* 1100011 */ + 0x92, /* 1001001 */ + 0xba, /* 1011101 */ + 0x92, /* 1001001 */ + 0xc6, /* 1100011 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + + /* 11 0x0b '^K' */ + 0x00, /* 0000000 */ + 0x1e, /* 0001111 */ + 0x0e, /* 0000111 */ + 0x1a, /* 0001101 */ + 0x1a, /* 0001101 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 12 0x0c '^L' */ + 0x00, /* 0000000 */ + 0x3c, /* 0011110 */ + 0x66, /* 0110011 */ + 0x66, /* 0110011 */ + 0x66, /* 0110011 */ + 0x66, /* 0110011 */ + 0x3c, /* 0011110 */ + 0x18, /* 0001100 */ + 0x7e, /* 0111111 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 13 0x0d '^M' */ + 0x00, /* 0000000 */ + 0x3e, /* 0011111 */ + 0x36, /* 0011011 */ + 0x3e, /* 0011111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x70, /* 0111000 */ + 0xf0, /* 1111000 */ + 0xe0, /* 1110000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 14 0x0e '^N' */ + 0x00, /* 0000000 */ + 0x7e, /* 0111111 */ + 0x66, /* 0110011 */ + 0x7e, /* 0111111 */ + 0x66, /* 0110011 */ + 0x66, /* 0110011 */ + 0x66, /* 0110011 */ + 0x66, /* 0110011 */ + 0x6e, /* 0110111 */ + 0xee, /* 1110111 */ + 0xec, /* 1110110 */ + 0xc0, /* 1100000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 15 0x0f '^O' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x10, /* 0001000 */ + 0x10, /* 0001000 */ + 0xd6, /* 1101011 */ + 0x38, /* 0011100 */ + 0xee, /* 1110111 */ + 0x38, /* 0011100 */ + 0xd6, /* 1101011 */ + 0x10, /* 0001000 */ + 0x10, /* 0001000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 16 0x10 '^P' */ + 0x00, /* 0000000 */ + 0x80, /* 1000000 */ + 0xc0, /* 1100000 */ + 0xe0, /* 1110000 */ + 0xf0, /* 1111000 */ + 0xfc, /* 1111110 */ + 0xf0, /* 1111000 */ + 0xe0, /* 1110000 */ + 0xc0, /* 1100000 */ + 0x80, /* 1000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 17 0x11 '^Q' */ + 0x00, /* 0000000 */ + 0x04, /* 0000010 */ + 0x0c, /* 0000110 */ + 0x1c, /* 0001110 */ + 0x3c, /* 0011110 */ + 0xfc, /* 1111110 */ + 0x3c, /* 0011110 */ + 0x1c, /* 0001110 */ + 0x0c, /* 0000110 */ + 0x04, /* 0000010 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 18 0x12 '^R' */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x3c, /* 0011110 */ + 0x7e, /* 0111111 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x7e, /* 0111111 */ + 0x3c, /* 0011110 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 19 0x13 '^S' */ + 0x00, /* 0000000 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 20 0x14 '^T' */ + 0x00, /* 0000000 */ + 0x7e, /* 0111111 */ + 0xd4, /* 1101010 */ + 0xd4, /* 1101010 */ + 0xd4, /* 1101010 */ + 0x74, /* 0111010 */ + 0x14, /* 0001010 */ + 0x14, /* 0001010 */ + 0x14, /* 0001010 */ + 0x14, /* 0001010 */ + 0x16, /* 0001011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 21 0x15 '^U' */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0x60, /* 0110000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0x18, /* 0001100 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 22 0x16 '^V' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xfc, /* 1111110 */ + 0xfc, /* 1111110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 23 0x17 '^W' */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x3c, /* 0011110 */ + 0x7e, /* 0111111 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x7e, /* 0111111 */ + 0x3c, /* 0011110 */ + 0x18, /* 0001100 */ + 0x7e, /* 0111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 24 0x18 '^X' */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x3c, /* 0011110 */ + 0x7e, /* 0111111 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 25 0x19 '^Y' */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x7e, /* 0111111 */ + 0x3c, /* 0011110 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 26 0x1a '^Z' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0xfc, /* 1111110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 27 0x1b '^[' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xfc, /* 1111110 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 28 0x1c '^\' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 29 0x1d '^]' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x28, /* 0010100 */ + 0x6c, /* 0110110 */ + 0xfe, /* 1111111 */ + 0x6c, /* 0110110 */ + 0x28, /* 0010100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 30 0x1e '^^' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x78, /* 0111100 */ + 0xfc, /* 1111110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 31 0x1f '^_' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xfc, /* 1111110 */ + 0x78, /* 0111100 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 32 0x20 ' ' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 33 0x21 '!' */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x3c, /* 0011110 */ + 0x3c, /* 0011110 */ + 0x3c, /* 0011110 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 34 0x22 '"' */ + 0x00, /* 0000000 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x28, /* 0010100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 35 0x23 '#' */ + 0x00, /* 0000000 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 36 0x24 '$' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xc4, /* 1100010 */ + 0xc0, /* 1100000 */ + 0x78, /* 0111100 */ + 0x0c, /* 0000110 */ + 0x8c, /* 1000110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + + /* 37 0x25 '%' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xc0, /* 1100000 */ + 0xc4, /* 1100010 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xcc, /* 1100110 */ + 0x8c, /* 1000110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 38 0x26 '&' */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0x78, /* 0111100 */ + 0xde, /* 1101111 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xdc, /* 1101110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 39 0x27 ''' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 40 0x28 '(' */ + 0x00, /* 0000000 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x0c, /* 0000110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 41 0x29 ')' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 42 0x2a '*' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0xfe, /* 1111111 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 43 0x2b '+' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x10, /* 0001000 */ + 0x10, /* 0001000 */ + 0x7c, /* 0111110 */ + 0x10, /* 0001000 */ + 0x10, /* 0001000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 44 0x2c ',' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 45 0x2d '-' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 46 0x2e '.' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 47 0x2f '/' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x04, /* 0000010 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xc0, /* 1100000 */ + 0x80, /* 1000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 48 0x30 '0' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xdc, /* 1101110 */ + 0xec, /* 1110110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 49 0x31 '1' */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x38, /* 0011100 */ + 0x78, /* 0111100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 50 0x32 '2' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 51 0x33 '3' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x38, /* 0011100 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 52 0x34 '4' */ + 0x00, /* 0000000 */ + 0x0c, /* 0000110 */ + 0x1c, /* 0001110 */ + 0x3c, /* 0011110 */ + 0x6c, /* 0110110 */ + 0xcc, /* 1100110 */ + 0xfe, /* 1111111 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 53 0x35 '5' */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xf8, /* 1111100 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 54 0x36 '6' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xf8, /* 1111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 55 0x37 '7' */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 56 0x38 '8' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 57 0x39 '9' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x7c, /* 0111110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x70, /* 0111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 58 0x3a ':' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 59 0x3b ';' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 60 0x3c '<' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x04, /* 0000010 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x0c, /* 0000110 */ + 0x04, /* 0000010 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 61 0x3d '=' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 62 0x3e '>' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x40, /* 0100000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x40, /* 0100000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 63 0x3f '?' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 64 0x40 '@' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xdc, /* 1101110 */ + 0xdc, /* 1101110 */ + 0xd8, /* 1101100 */ + 0xc0, /* 1100000 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 65 0x41 'A' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 66 0x42 'B' */ + 0x00, /* 0000000 */ + 0xf8, /* 1111100 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x78, /* 0111100 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xf8, /* 1111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 67 0x43 'C' */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0xc4, /* 1100010 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc4, /* 1100010 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 68 0x44 'D' */ + 0x00, /* 0000000 */ + 0xf0, /* 1111000 */ + 0xd8, /* 1101100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xd8, /* 1101100 */ + 0xf0, /* 1111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 69 0x45 'E' */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0x6c, /* 0110110 */ + 0x64, /* 0110010 */ + 0x68, /* 0110100 */ + 0x78, /* 0111100 */ + 0x68, /* 0110100 */ + 0x60, /* 0110000 */ + 0x64, /* 0110010 */ + 0x6c, /* 0110110 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 70 0x46 'F' */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0x64, /* 0110010 */ + 0x60, /* 0110000 */ + 0x68, /* 0110100 */ + 0x78, /* 0111100 */ + 0x68, /* 0110100 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x70, /* 0111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 71 0x47 'G' */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0xc4, /* 1100010 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xdc, /* 1101110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x6c, /* 0110110 */ + 0x34, /* 0011010 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 72 0x48 'H' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 73 0x49 'I' */ + 0x00, /* 0000000 */ + 0x3c, /* 0011110 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x3c, /* 0011110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 74 0x4a 'J' */ + 0x00, /* 0000000 */ + 0x1c, /* 0001110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 75 0x4b 'K' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xd8, /* 1101100 */ + 0xf0, /* 1111000 */ + 0xf0, /* 1111000 */ + 0xd8, /* 1101100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 76 0x4c 'L' */ + 0x00, /* 0000000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc4, /* 1100010 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 77 0x4d 'M' */ + 0x00, /* 0000000 */ + 0xc6, /* 1100011 */ + 0xee, /* 1110111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xd6, /* 1101011 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 78 0x4e 'N' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xec, /* 1110110 */ + 0xec, /* 1110110 */ + 0xfc, /* 1111110 */ + 0xdc, /* 1101110 */ + 0xdc, /* 1101110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 79 0x4f 'O' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 80 0x50 'P' */ + 0x00, /* 0000000 */ + 0xf8, /* 1111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xf8, /* 1111100 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 81 0x51 'Q' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xdc, /* 1101110 */ + 0x78, /* 0111100 */ + 0x18, /* 0001100 */ + 0x1c, /* 0001110 */ + 0x00, /* 0000000 */ + + /* 82 0x52 'R' */ + 0x00, /* 0000000 */ + 0xf8, /* 1111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xf8, /* 1111100 */ + 0xd8, /* 1101100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 83 0x53 'S' */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0xc4, /* 1100010 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0x60, /* 0110000 */ + 0x38, /* 0011100 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x8c, /* 1000110 */ + 0xf8, /* 1111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 84 0x54 'T' */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xfc, /* 1111110 */ + 0xb4, /* 1011010 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 85 0x55 'U' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 86 0x56 'V' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 87 0x57 'W' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xfc, /* 1111110 */ + 0x48, /* 0100100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 88 0x58 'X' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 89 0x59 'Y' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 90 0x5a 'Z' */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0x8c, /* 1000110 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xc4, /* 1100010 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 91 0x5b '[' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 92 0x5c '\' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x80, /* 1000000 */ + 0xc0, /* 1100000 */ + 0xe0, /* 1110000 */ + 0x70, /* 0111000 */ + 0x38, /* 0011100 */ + 0x1c, /* 0001110 */ + 0x0c, /* 0000110 */ + 0x04, /* 0000010 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 93 0x5d ']' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 94 0x5e '^' */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0xc6, /* 1100011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 95 0x5f '_' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + + /* 96 0x60 '`' */ + 0x00, /* 0000000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 97 0x61 'a' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0x0c, /* 0000110 */ + 0x7c, /* 0111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 98 0x62 'b' */ + 0x00, /* 0000000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xf0, /* 1111000 */ + 0xd8, /* 1101100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xf8, /* 1111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 99 0x63 'c' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 100 0x64 'd' */ + 0x00, /* 0000000 */ + 0x1c, /* 0001110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x3c, /* 0011110 */ + 0x6c, /* 0110110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 101 0x65 'e' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 102 0x66 'f' */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x64, /* 0110010 */ + 0x60, /* 0110000 */ + 0xf0, /* 1111000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0xf0, /* 1111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 103 0x67 'g' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x76, /* 0111011 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x7c, /* 0111110 */ + 0x0c, /* 0000110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + + /* 104 0x68 'h' */ + 0x00, /* 0000000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xd8, /* 1101100 */ + 0xec, /* 1110110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 105 0x69 'i' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x70, /* 0111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 106 0x6a 'j' */ + 0x00, /* 0000000 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x00, /* 0000000 */ + 0x1c, /* 0001110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + + /* 107 0x6b 'k' */ + 0x00, /* 0000000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0xd8, /* 1101100 */ + 0xf0, /* 1111000 */ + 0xf0, /* 1111000 */ + 0xd8, /* 1101100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 108 0x6c 'l' */ + 0x00, /* 0000000 */ + 0x70, /* 0111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 109 0x6d 'm' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xec, /* 1110110 */ + 0xfe, /* 1111111 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 110 0x6e 'n' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xb8, /* 1011100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 111 0x6f 'o' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 112 0x70 'p' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xb8, /* 1011100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xf8, /* 1111100 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + + /* 113 0x71 'q' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x74, /* 0111010 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x7c, /* 0111110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + + /* 114 0x72 'r' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xb8, /* 1011100 */ + 0xec, /* 1110110 */ + 0xcc, /* 1100110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 115 0x73 's' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 116 0x74 't' */ + 0x00, /* 0000000 */ + 0x10, /* 0001000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xfc, /* 1111110 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x36, /* 0011011 */ + 0x1c, /* 0001110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 117 0x75 'u' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 118 0x76 'v' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 119 0x77 'w' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0xfe, /* 1111111 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 120 0x78 'x' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 121 0x79 'y' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x7c, /* 0111110 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0xf0, /* 1111000 */ + + /* 122 0x7a 'z' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 123 0x7b '{' */ + 0x00, /* 0000000 */ + 0x1c, /* 0001110 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xe0, /* 1110000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x1c, /* 0001110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 124 0x7c '|' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 125 0x7d '}' */ + 0x00, /* 0000000 */ + 0x70, /* 0111000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x0e, /* 0000111 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x70, /* 0111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 126 0x7e '~' */ + 0x00, /* 0000000 */ + 0xec, /* 1110110 */ + 0xb8, /* 1011100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 127 0x7f '' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 128 0x80 'Ç' */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0xc4, /* 1100010 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc4, /* 1100010 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0x18, /* 0001100 */ + 0x70, /* 0111000 */ + 0x00, /* 0000000 */ + + /* 129 0x81 'ü' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 130 0x82 'é' */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 131 0x83 'â' */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0x0c, /* 0000110 */ + 0x7c, /* 0111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 132 0x84 'ä' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0x0c, /* 0000110 */ + 0x7c, /* 0111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 133 0x85 'à' */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0x0c, /* 0000110 */ + 0x7c, /* 0111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 134 0x86 'å' */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0x0c, /* 0000110 */ + 0x7c, /* 0111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 135 0x87 'ç' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xe0, /* 1110000 */ + + /* 136 0x88 'ê' */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 137 0x89 'ë' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 138 0x8a 'è' */ + 0xc0, /* 1100000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 139 0x8b 'ï' */ + 0x00, /* 0000000 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x3c, /* 0011110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 140 0x8c 'î' */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x70, /* 0111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 141 0x8d 'ì' */ + 0xc0, /* 1100000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x70, /* 0111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 142 0x8e 'Ä' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 143 0x8f 'Å' */ + 0x30, /* 0011000 */ + 0x48, /* 0100100 */ + 0x48, /* 0100100 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 144 0x90 'É' */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0xc4, /* 1100010 */ + 0xd0, /* 1101000 */ + 0xf0, /* 1111000 */ + 0xd0, /* 1101000 */ + 0xc4, /* 1100010 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 145 0x91 'æ' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xec, /* 1110110 */ + 0x36, /* 0011011 */ + 0x36, /* 0011011 */ + 0x7e, /* 0111111 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0x6e, /* 0110111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 146 0x92 'Æ' */ + 0x00, /* 0000000 */ + 0x3e, /* 0011111 */ + 0x6c, /* 0110110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xfe, /* 1111111 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xce, /* 1100111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 147 0x93 'ô' */ + 0x10, /* 0001000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 148 0x94 'ö' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 149 0x95 'ò' */ + 0xc0, /* 1100000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 150 0x96 'û' */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 151 0x97 'ù' */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 152 0x98 'ÿ' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x7c, /* 0111110 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x70, /* 0111000 */ + + /* 153 0x99 'Ö' */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 154 0x9a 'Ü' */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 155 0x9b '¢' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x7c, /* 0111110 */ + 0xcc, /* 1100110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0x7c, /* 0111110 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 156 0x9c '£' */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x64, /* 0110010 */ + 0x60, /* 0110000 */ + 0xf0, /* 1111000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0xe6, /* 1110011 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 157 0x9d '¥' */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0xfc, /* 1111110 */ + 0x30, /* 0011000 */ + 0xfc, /* 1111110 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 158 0x9e '₧' */ + 0xf8, /* 1111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xf8, /* 1111100 */ + 0xc4, /* 1100010 */ + 0xcc, /* 1100110 */ + 0xde, /* 1101111 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xc6, /* 1100011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 159 0x9f 'ƒ' */ + 0x1c, /* 0001110 */ + 0x36, /* 0011011 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xfc, /* 1111110 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xb0, /* 1011000 */ + 0xe0, /* 1110000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 160 0xa0 'á' */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0x0c, /* 0000110 */ + 0x7c, /* 0111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 161 0xa1 'í' */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x00, /* 0000000 */ + 0x70, /* 0111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 162 0xa2 'ó' */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 163 0xa3 'ú' */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 164 0xa4 'ñ' */ + 0x00, /* 0000000 */ + 0x76, /* 0111011 */ + 0xdc, /* 1101110 */ + 0x00, /* 0000000 */ + 0xb8, /* 1011100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 165 0xa5 'Ñ' */ + 0x76, /* 0111011 */ + 0xdc, /* 1101110 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xec, /* 1110110 */ + 0xec, /* 1110110 */ + 0xfc, /* 1111110 */ + 0xdc, /* 1101110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 166 0xa6 'ª' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 167 0xa7 'º' */ + 0x00, /* 0000000 */ + 0x70, /* 0111000 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0x70, /* 0111000 */ + 0x00, /* 0000000 */ + 0xf8, /* 1111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 168 0xa8 '¿' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xc0, /* 1100000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 169 0xa9 '⌐' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 170 0xaa '¬' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 171 0xab '½' */ + 0x60, /* 0110000 */ + 0xe0, /* 1110000 */ + 0x62, /* 0110001 */ + 0x66, /* 0110011 */ + 0x6c, /* 0110110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xc0, /* 1100000 */ + 0xb8, /* 1011100 */ + 0x4c, /* 0100110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x7c, /* 0111110 */ + + /* 172 0xac '¼' */ + 0x60, /* 0110000 */ + 0xe0, /* 1110000 */ + 0x62, /* 0110001 */ + 0x66, /* 0110011 */ + 0x6c, /* 0110110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x6c, /* 0110110 */ + 0xdc, /* 1101110 */ + 0xb4, /* 1011010 */ + 0x7e, /* 0111111 */ + 0x0c, /* 0000110 */ + 0x0c, /* 0000110 */ + 0x00, /* 0000000 */ + + /* 173 0xad '¡' */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0x78, /* 0111100 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 174 0xae '«' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x36, /* 0011011 */ + 0x6c, /* 0110110 */ + 0xd8, /* 1101100 */ + 0x6c, /* 0110110 */ + 0x36, /* 0011011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 175 0xaf '»' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xd8, /* 1101100 */ + 0x6c, /* 0110110 */ + 0x36, /* 0011011 */ + 0x6c, /* 0110110 */ + 0xd8, /* 1101100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 176 0xb0 '░' */ + 0x88, /* 1000100 */ + 0x22, /* 0010001 */ + 0x88, /* 1000100 */ + 0x22, /* 0010001 */ + 0x88, /* 1000100 */ + 0x22, /* 0010001 */ + 0x88, /* 1000100 */ + 0x22, /* 0010001 */ + 0x88, /* 1000100 */ + 0x22, /* 0010001 */ + 0x88, /* 1000100 */ + 0x22, /* 0010001 */ + 0x88, /* 1000100 */ + 0x22, /* 0010001 */ + + /* 177 0xb1 '▒' */ + 0x54, /* 0101010 */ + 0xaa, /* 1010101 */ + 0x54, /* 0101010 */ + 0xaa, /* 1010101 */ + 0x54, /* 0101010 */ + 0xaa, /* 1010101 */ + 0x54, /* 0101010 */ + 0xaa, /* 1010101 */ + 0x54, /* 0101010 */ + 0xaa, /* 1010101 */ + 0x54, /* 0101010 */ + 0xaa, /* 1010101 */ + 0x54, /* 0101010 */ + 0xaa, /* 1010101 */ + + /* 178 0xb2 '▓' */ + 0xee, /* 1110111 */ + 0xba, /* 1011101 */ + 0xee, /* 1110111 */ + 0xba, /* 1011101 */ + 0xee, /* 1110111 */ + 0xba, /* 1011101 */ + 0xee, /* 1110111 */ + 0xba, /* 1011101 */ + 0xee, /* 1110111 */ + 0xba, /* 1011101 */ + 0xee, /* 1110111 */ + 0xba, /* 1011101 */ + 0xee, /* 1110111 */ + 0xba, /* 1011101 */ + + /* 179 0xb3 '│' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 180 0xb4 '┤' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xf0, /* 1111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 181 0xb5 '╡' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xf0, /* 1111000 */ + 0x30, /* 0011000 */ + 0xf0, /* 1111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 182 0xb6 '╢' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xec, /* 1110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 183 0xb7 '╖' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 184 0xb8 '╕' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xf0, /* 1111000 */ + 0x30, /* 0011000 */ + 0xf0, /* 1111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 185 0xb9 '╣' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xec, /* 1110110 */ + 0x0c, /* 0000110 */ + 0xec, /* 1110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 186 0xba '║' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 187 0xbb '╗' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x0c, /* 0000110 */ + 0xec, /* 1110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 188 0xbc '╝' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xec, /* 1110110 */ + 0x0c, /* 0000110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 189 0xbd '╜' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 190 0xbe '╛' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xf0, /* 1111000 */ + 0x30, /* 0011000 */ + 0xf0, /* 1111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 191 0xbf '┐' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xf0, /* 1111000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 192 0xc0 '└' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x3e, /* 0011111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 193 0xc1 '┴' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 194 0xc2 '┬' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 195 0xc3 '├' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x3e, /* 0011111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 196 0xc4 '─' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 197 0xc5 '┼' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xfe, /* 1111111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 198 0xc6 '╞' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x3e, /* 0011111 */ + 0x30, /* 0011000 */ + 0x3e, /* 0011111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 199 0xc7 '╟' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6e, /* 0110111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 200 0xc8 '╚' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6e, /* 0110111 */ + 0x60, /* 0110000 */ + 0x7e, /* 0111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 201 0xc9 '╔' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x7e, /* 0111111 */ + 0x60, /* 0110000 */ + 0x6e, /* 0110111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 202 0xca '╩' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xee, /* 1110111 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 203 0xcb '╦' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0xee, /* 1110111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 204 0xcc '╠' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6e, /* 0110111 */ + 0x60, /* 0110000 */ + 0x6e, /* 0110111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 205 0xcd '═' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 206 0xce '╬' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xee, /* 1110111 */ + 0x00, /* 0000000 */ + 0xee, /* 1110111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 207 0xcf '╧' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 208 0xd0 '╨' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 209 0xd1 '╤' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 210 0xd2 '╥' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 211 0xd3 '╙' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x7e, /* 0111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 212 0xd4 '╘' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x3e, /* 0011111 */ + 0x30, /* 0011000 */ + 0x3e, /* 0011111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 213 0xd5 '╒' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x3e, /* 0011111 */ + 0x30, /* 0011000 */ + 0x3e, /* 0011111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 214 0xd6 '╓' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x7e, /* 0111111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 215 0xd7 '╫' */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xfe, /* 1111111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + + /* 216 0xd8 '╪' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xfe, /* 1111111 */ + 0x30, /* 0011000 */ + 0xfe, /* 1111111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 217 0xd9 '┘' */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xf0, /* 1111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 218 0xda '┌' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x3e, /* 0011111 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 219 0xdb '█' */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + + /* 220 0xdc '▄' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + + /* 221 0xdd '▌' */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + 0xe0, /* 1110000 */ + + /* 222 0xde '▐' */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + 0x1e, /* 0001111 */ + + /* 223 0xdf '▀' */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 224 0xe0 'α' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x76, /* 0111011 */ + 0xdc, /* 1101110 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0xdc, /* 1101110 */ + 0x76, /* 0111011 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 225 0xe1 'ß' */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xd8, /* 1101100 */ + 0xcc, /* 1100110 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 226 0xe2 'Γ' */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 227 0xe3 'π' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfe, /* 1111111 */ + 0xfe, /* 1111111 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 228 0xe4 'Σ' */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 229 0xe5 'σ' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x7e, /* 0111111 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0x70, /* 0111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 230 0xe6 'µ' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xf8, /* 1111100 */ + 0xc0, /* 1100000 */ + 0xc0, /* 1100000 */ + 0x80, /* 1000000 */ + + /* 231 0xe7 'τ' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x76, /* 0111011 */ + 0xdc, /* 1101110 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 232 0xe8 'Φ' */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x30, /* 0011000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x30, /* 0011000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 233 0xe9 'Θ' */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xfc, /* 1111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 234 0xea 'Ω' */ + 0x00, /* 0000000 */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0xc6, /* 1100011 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0xee, /* 1110111 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 235 0xeb 'δ' */ + 0x00, /* 0000000 */ + 0x3c, /* 0011110 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x7c, /* 0111110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x78, /* 0111100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 236 0xec '∞' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 237 0xed 'φ' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x06, /* 0000011 */ + 0x0c, /* 0000110 */ + 0x7c, /* 0111110 */ + 0xd6, /* 1101011 */ + 0xd6, /* 1101011 */ + 0xe6, /* 1110011 */ + 0x7c, /* 0111110 */ + 0x60, /* 0110000 */ + 0xc0, /* 1100000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 238 0xee 'ε' */ + 0x00, /* 0000000 */ + 0x1c, /* 0001110 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x7c, /* 0111110 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x1c, /* 0001110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 239 0xef '∩' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0xcc, /* 1100110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 240 0xf0 '≡' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 241 0xf1 '±' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0xfc, /* 1111110 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 242 0xf2 '≥' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x0c, /* 0000110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 243 0xf3 '≤' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x60, /* 0110000 */ + 0xc0, /* 1100000 */ + 0x60, /* 0110000 */ + 0x30, /* 0011000 */ + 0x18, /* 0001100 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 244 0xf4 '⌠' */ + 0x00, /* 0000000 */ + 0x1c, /* 0001110 */ + 0x36, /* 0011011 */ + 0x36, /* 0011011 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + + /* 245 0xf5 '⌡' */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0x70, /* 0111000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 246 0xf6 '÷' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 247 0xf7 '≈' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x76, /* 0111011 */ + 0xdc, /* 1101110 */ + 0x00, /* 0000000 */ + 0x76, /* 0111011 */ + 0xdc, /* 1101110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 248 0xf8 '°' */ + 0x38, /* 0011100 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x38, /* 0011100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 249 0xf9 '·' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 250 0xfa '•' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x30, /* 0011000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 251 0xfb '√' */ + 0x1e, /* 0001111 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0x18, /* 0001100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0xd8, /* 1101100 */ + 0x78, /* 0111100 */ + 0x38, /* 0011100 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 252 0xfc 'ⁿ' */ + 0xd8, /* 1101100 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x6c, /* 0110110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 253 0xfd '²' */ + 0x78, /* 0111100 */ + 0xcc, /* 1100110 */ + 0x18, /* 0001100 */ + 0x30, /* 0011000 */ + 0x64, /* 0110010 */ + 0xfc, /* 1111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 254 0xfe '■' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x7c, /* 0111110 */ + 0x7c, /* 0111110 */ + 0x7c, /* 0111110 */ + 0x7c, /* 0111110 */ + 0x7c, /* 0111110 */ + 0x7c, /* 0111110 */ + 0x7c, /* 0111110 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + + /* 255 0xff ' ' */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + 0x00, /* 0000000 */ + +}; diff --git a/kernel/graphics/fonts/font_8x16.h b/kernel/graphics/fonts/font_8x16.h new file mode 100644 index 0000000..2cce262 --- /dev/null +++ b/kernel/graphics/fonts/font_8x16.h @@ -0,0 +1,4618 @@ + +/**********************************************/ +/* */ +/* Font file generated by cpi2fnt */ +/* */ +/**********************************************/ + +static const unsigned char fontdata_8x16[] = { + + /* 0 0x00 '^@' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 1 0x01 '^A' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x81, /* 10000001 */ + 0xa5, /* 10100101 */ + 0x81, /* 10000001 */ + 0x81, /* 10000001 */ + 0xbd, /* 10111101 */ + 0x99, /* 10011001 */ + 0x81, /* 10000001 */ + 0x81, /* 10000001 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 2 0x02 '^B' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xff, /* 11111111 */ + 0xdb, /* 11011011 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xc3, /* 11000011 */ + 0xe7, /* 11100111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 3 0x03 '^C' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 4 0x04 '^D' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 5 0x05 '^E' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0xe7, /* 11100111 */ + 0xe7, /* 11100111 */ + 0xe7, /* 11100111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 6 0x06 '^F' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 7 0x07 '^G' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 8 0x08 '^H' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xe7, /* 11100111 */ + 0xc3, /* 11000011 */ + 0xc3, /* 11000011 */ + 0xe7, /* 11100111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 9 0x09 '^I' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x42, /* 01000010 */ + 0x42, /* 01000010 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 10 0x0a '^J' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xc3, /* 11000011 */ + 0x99, /* 10011001 */ + 0xbd, /* 10111101 */ + 0xbd, /* 10111101 */ + 0x99, /* 10011001 */ + 0xc3, /* 11000011 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 11 0x0b '^K' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1e, /* 00011110 */ + 0x0e, /* 00001110 */ + 0x1a, /* 00011010 */ + 0x32, /* 00110010 */ + 0x78, /* 01111000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 12 0x0c '^L' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 13 0x0d '^M' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3f, /* 00111111 */ + 0x33, /* 00110011 */ + 0x3f, /* 00111111 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x70, /* 01110000 */ + 0xf0, /* 11110000 */ + 0xe0, /* 11100000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 14 0x0e '^N' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7f, /* 01111111 */ + 0x63, /* 01100011 */ + 0x7f, /* 01111111 */ + 0x63, /* 01100011 */ + 0x63, /* 01100011 */ + 0x63, /* 01100011 */ + 0x63, /* 01100011 */ + 0x67, /* 01100111 */ + 0xe7, /* 11100111 */ + 0xe6, /* 11100110 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 15 0x0f '^O' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xdb, /* 11011011 */ + 0x3c, /* 00111100 */ + 0xe7, /* 11100111 */ + 0x3c, /* 00111100 */ + 0xdb, /* 11011011 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 16 0x10 '^P' */ + 0x00, /* 00000000 */ + 0x80, /* 10000000 */ + 0xc0, /* 11000000 */ + 0xe0, /* 11100000 */ + 0xf0, /* 11110000 */ + 0xf8, /* 11111000 */ + 0xfe, /* 11111110 */ + 0xf8, /* 11111000 */ + 0xf0, /* 11110000 */ + 0xe0, /* 11100000 */ + 0xc0, /* 11000000 */ + 0x80, /* 10000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 17 0x11 '^Q' */ + 0x00, /* 00000000 */ + 0x02, /* 00000010 */ + 0x06, /* 00000110 */ + 0x0e, /* 00001110 */ + 0x1e, /* 00011110 */ + 0x3e, /* 00111110 */ + 0xfe, /* 11111110 */ + 0x3e, /* 00111110 */ + 0x1e, /* 00011110 */ + 0x0e, /* 00001110 */ + 0x06, /* 00000110 */ + 0x02, /* 00000010 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 18 0x12 '^R' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 19 0x13 '^S' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 20 0x14 '^T' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7f, /* 01111111 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0x7b, /* 01111011 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 21 0x15 '^U' */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x60, /* 01100000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x0c, /* 00001100 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 22 0x16 '^V' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 23 0x17 '^W' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 24 0x18 '^X' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 25 0x19 '^Y' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 26 0x1a '^Z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0xfe, /* 11111110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 27 0x1b '^[' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xfe, /* 11111110 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 28 0x1c '^\' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 29 0x1d '^]' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x28, /* 00101000 */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x28, /* 00101000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 30 0x1e '^^' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0x7c, /* 01111100 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 31 0x1f '^_' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 32 0x20 ' ' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 33 0x21 '!' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 34 0x22 '"' */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x24, /* 00100100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 35 0x23 '#' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 36 0x24 '$' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc2, /* 11000010 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x86, /* 10000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 37 0x25 '%' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc2, /* 11000010 */ + 0xc6, /* 11000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc6, /* 11000110 */ + 0x86, /* 10000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 38 0x26 '&' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 39 0x27 ''' */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 40 0x28 '(' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 41 0x29 ')' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 42 0x2a '*' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0xff, /* 11111111 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 43 0x2b '+' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 44 0x2c ',' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 45 0x2d '-' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 46 0x2e '.' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 47 0x2f '/' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x02, /* 00000010 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0x80, /* 10000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 48 0x30 '0' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 49 0x31 '1' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x38, /* 00111000 */ + 0x78, /* 01111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 50 0x32 '2' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 51 0x33 '3' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x3c, /* 00111100 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 52 0x34 '4' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x0c, /* 00001100 */ + 0x1c, /* 00011100 */ + 0x3c, /* 00111100 */ + 0x6c, /* 01101100 */ + 0xcc, /* 11001100 */ + 0xfe, /* 11111110 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x1e, /* 00011110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 53 0x35 '5' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfc, /* 11111100 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 54 0x36 '6' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 55 0x37 '7' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 56 0x38 '8' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 57 0x39 '9' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 58 0x3a ':' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 59 0x3b ';' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 60 0x3c '<' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 61 0x3d '=' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 62 0x3e '>' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 63 0x3f '?' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 64 0x40 '@' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xde, /* 11011110 */ + 0xde, /* 11011110 */ + 0xde, /* 11011110 */ + 0xdc, /* 11011100 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 65 0x41 'A' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 66 0x42 'B' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 11111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 67 0x43 'C' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0xc2, /* 11000010 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc2, /* 11000010 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 68 0x44 'D' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 11111000 */ + 0x6c, /* 01101100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x6c, /* 01101100 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 69 0x45 'E' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x66, /* 01100110 */ + 0x62, /* 01100010 */ + 0x68, /* 01101000 */ + 0x78, /* 01111000 */ + 0x68, /* 01101000 */ + 0x60, /* 01100000 */ + 0x62, /* 01100010 */ + 0x66, /* 01100110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 70 0x46 'F' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x66, /* 01100110 */ + 0x62, /* 01100010 */ + 0x68, /* 01101000 */ + 0x78, /* 01111000 */ + 0x68, /* 01101000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 71 0x47 'G' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0xc2, /* 11000010 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xde, /* 11011110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x66, /* 01100110 */ + 0x3a, /* 00111010 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 72 0x48 'H' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 73 0x49 'I' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 74 0x4a 'J' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1e, /* 00011110 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 75 0x4b 'K' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xe6, /* 11100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x6c, /* 01101100 */ + 0x78, /* 01111000 */ + 0x78, /* 01111000 */ + 0x6c, /* 01101100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0xe6, /* 11100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 76 0x4c 'L' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf0, /* 11110000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x62, /* 01100010 */ + 0x66, /* 01100110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 77 0x4d 'M' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xee, /* 11101110 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xd6, /* 11010110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 78 0x4e 'N' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xe6, /* 11100110 */ + 0xf6, /* 11110110 */ + 0xfe, /* 11111110 */ + 0xde, /* 11011110 */ + 0xce, /* 11001110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 79 0x4f 'O' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 80 0x50 'P' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 11111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 81 0x51 'Q' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xde, /* 11011110 */ + 0x7c, /* 01111100 */ + 0x0c, /* 00001100 */ + 0x0e, /* 00001110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 82 0x52 'R' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 11111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x6c, /* 01101100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0xe6, /* 11100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 83 0x53 'S' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x60, /* 01100000 */ + 0x38, /* 00111000 */ + 0x0c, /* 00001100 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 84 0x54 'T' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x5a, /* 01011010 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 85 0x55 'U' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 86 0x56 'V' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 87 0x57 'W' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xfe, /* 11111110 */ + 0xee, /* 11101110 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 88 0x58 'X' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 89 0x59 'Y' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 90 0x5a 'Z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x86, /* 10000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc2, /* 11000010 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 91 0x5b '[' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 92 0x5c '\' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x80, /* 10000000 */ + 0xc0, /* 11000000 */ + 0xe0, /* 11100000 */ + 0x70, /* 01110000 */ + 0x38, /* 00111000 */ + 0x1c, /* 00011100 */ + 0x0e, /* 00001110 */ + 0x06, /* 00000110 */ + 0x02, /* 00000010 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 93 0x5d ']' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 94 0x5e '^' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 95 0x5f '_' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 96 0x60 '`' */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 97 0x61 'a' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 98 0x62 'b' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xe0, /* 11100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x78, /* 01111000 */ + 0x6c, /* 01101100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 99 0x63 'c' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 100 0x64 'd' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1c, /* 00011100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x3c, /* 00111100 */ + 0x6c, /* 01101100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 101 0x65 'e' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 102 0x66 'f' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1c, /* 00011100 */ + 0x36, /* 00110110 */ + 0x32, /* 00110010 */ + 0x30, /* 00110000 */ + 0x78, /* 01111000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 103 0x67 'g' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x7c, /* 01111100 */ + 0x0c, /* 00001100 */ + 0xcc, /* 11001100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + + /* 104 0x68 'h' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xe0, /* 11100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x6c, /* 01101100 */ + 0x76, /* 01110110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0xe6, /* 11100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 105 0x69 'i' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 106 0x6a 'j' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + 0x0e, /* 00001110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 107 0x6b 'k' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xe0, /* 11100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x66, /* 01100110 */ + 0x6c, /* 01101100 */ + 0x78, /* 01111000 */ + 0x78, /* 01111000 */ + 0x6c, /* 01101100 */ + 0x66, /* 01100110 */ + 0xe6, /* 11100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 108 0x6c 'l' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 109 0x6d 'm' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xec, /* 11101100 */ + 0xfe, /* 11111110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 110 0x6e 'n' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 111 0x6f 'o' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 112 0x70 'p' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x00, /* 00000000 */ + + /* 113 0x71 'q' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x7c, /* 01111100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x1e, /* 00011110 */ + 0x00, /* 00000000 */ + + /* 114 0x72 'r' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x76, /* 01110110 */ + 0x66, /* 01100110 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 115 0x73 's' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x60, /* 01100000 */ + 0x38, /* 00111000 */ + 0x0c, /* 00001100 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 116 0x74 't' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0xfc, /* 11111100 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x36, /* 00110110 */ + 0x1c, /* 00011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 117 0x75 'u' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 118 0x76 'v' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 119 0x77 'w' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 120 0x78 'x' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 121 0x79 'y' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + + /* 122 0x7a 'z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xcc, /* 11001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 123 0x7b '{' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x0e, /* 00001110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x70, /* 01110000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x0e, /* 00001110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 124 0x7c '|' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 125 0x7d '}' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x70, /* 01110000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x0e, /* 00001110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 126 0x7e '~' */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 127 0x7f '' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 128 0x80 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0xc2, /* 11000010 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc2, /* 11000010 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 129 0x81 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 130 0x82 '�' */ + 0x00, /* 00000000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 131 0x83 '�' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 132 0x84 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 133 0x85 '�' */ + 0x00, /* 00000000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 134 0x86 '�' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 135 0x87 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x18, /* 00011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 136 0x88 '�' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 137 0x89 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 138 0x8a '�' */ + 0x00, /* 00000000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 139 0x8b '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 140 0x8c '�' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 141 0x8d '�' */ + 0x00, /* 00000000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 142 0x8e '�' */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 143 0x8f '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 144 0x90 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x66, /* 01100110 */ + 0x62, /* 01100010 */ + 0x68, /* 01101000 */ + 0x78, /* 01111000 */ + 0x68, /* 01101000 */ + 0x62, /* 01100010 */ + 0x66, /* 01100110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 145 0x91 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xec, /* 11101100 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x7e, /* 01111110 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0x6e, /* 01101110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 146 0x92 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3e, /* 00111110 */ + 0x6c, /* 01101100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xfe, /* 11111110 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xce, /* 11001110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 147 0x93 '�' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 148 0x94 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 149 0x95 '�' */ + 0x00, /* 00000000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 150 0x96 '�' */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x78, /* 01111000 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 151 0x97 '�' */ + 0x00, /* 00000000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 152 0x98 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + + /* 153 0x99 '�' */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 154 0x9a '�' */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 155 0x9b '�' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 156 0x9c '�' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x64, /* 01100100 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xe6, /* 11100110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 157 0x9d '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 158 0x9e '�' */ + 0x00, /* 00000000 */ + 0xf8, /* 11111000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xf8, /* 11111000 */ + 0xc4, /* 11000100 */ + 0xcc, /* 11001100 */ + 0xde, /* 11011110 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 159 0x9f '�' */ + 0x00, /* 00000000 */ + 0x0e, /* 00001110 */ + 0x1b, /* 00011011 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 160 0xa0 '�' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 161 0xa1 '�' */ + 0x00, /* 00000000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 162 0xa2 '�' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 163 0xa3 '�' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 164 0xa4 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 165 0xa5 '�' */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xe6, /* 11100110 */ + 0xf6, /* 11110110 */ + 0xfe, /* 11111110 */ + 0xde, /* 11011110 */ + 0xce, /* 11001110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 166 0xa6 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x3e, /* 00111110 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 167 0xa7 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 168 0xa8 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 169 0xa9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 170 0xaa '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 171 0xab '�' */ + 0x00, /* 00000000 */ + 0x60, /* 01100000 */ + 0xe0, /* 11100000 */ + 0x62, /* 01100010 */ + 0x66, /* 01100110 */ + 0x6c, /* 01101100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xdc, /* 11011100 */ + 0x86, /* 10000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x3e, /* 00111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 172 0xac '�' */ + 0x00, /* 00000000 */ + 0x60, /* 01100000 */ + 0xe0, /* 11100000 */ + 0x62, /* 01100010 */ + 0x66, /* 01100110 */ + 0x6c, /* 01101100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x66, /* 01100110 */ + 0xce, /* 11001110 */ + 0x9a, /* 10011010 */ + 0x3f, /* 00111111 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 173 0xad '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 174 0xae '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x36, /* 00110110 */ + 0x6c, /* 01101100 */ + 0xd8, /* 11011000 */ + 0x6c, /* 01101100 */ + 0x36, /* 00110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 175 0xaf '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xd8, /* 11011000 */ + 0x6c, /* 01101100 */ + 0x36, /* 00110110 */ + 0x6c, /* 01101100 */ + 0xd8, /* 11011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 176 0xb0 '�' */ + 0x11, /* 00010001 */ + 0x44, /* 01000100 */ + 0x11, /* 00010001 */ + 0x44, /* 01000100 */ + 0x11, /* 00010001 */ + 0x44, /* 01000100 */ + 0x11, /* 00010001 */ + 0x44, /* 01000100 */ + 0x11, /* 00010001 */ + 0x44, /* 01000100 */ + 0x11, /* 00010001 */ + 0x44, /* 01000100 */ + 0x11, /* 00010001 */ + 0x44, /* 01000100 */ + 0x11, /* 00010001 */ + 0x44, /* 01000100 */ + + /* 177 0xb1 '�' */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + + /* 178 0xb2 '�' */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + + /* 179 0xb3 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 180 0xb4 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 181 0xb5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 182 0xb6 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 183 0xb7 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 184 0xb8 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 185 0xb9 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x06, /* 00000110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 186 0xba '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 187 0xbb '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x06, /* 00000110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 188 0xbc '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x06, /* 00000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 189 0xbd '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 190 0xbe '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 191 0xbf '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 192 0xc0 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 193 0xc1 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 194 0xc2 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 195 0xc3 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 196 0xc4 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 197 0xc5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 198 0xc6 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 199 0xc7 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 200 0xc8 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x30, /* 00110000 */ + 0x3f, /* 00111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 201 0xc9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3f, /* 00111111 */ + 0x30, /* 00110000 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 202 0xca '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf7, /* 11110111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 203 0xcb '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xf7, /* 11110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 204 0xcc '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x30, /* 00110000 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 205 0xcd '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 206 0xce '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf7, /* 11110111 */ + 0x00, /* 00000000 */ + 0xf7, /* 11110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 207 0xcf '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 208 0xd0 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 209 0xd1 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 210 0xd2 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 211 0xd3 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x3f, /* 00111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 212 0xd4 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 213 0xd5 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 214 0xd6 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3f, /* 00111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 215 0xd7 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xff, /* 11111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 216 0xd8 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 217 0xd9 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 218 0xda '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 219 0xdb '�' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 220 0xdc '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 221 0xdd '�' */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + + /* 222 0xde '�' */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + + /* 223 0xdf '�' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 224 0xe0 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0xdc, /* 11011100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 225 0xe1 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xd8, /* 11011000 */ + 0xcc, /* 11001100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 226 0xe2 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 227 0xe3 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 228 0xe4 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 229 0xe5 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 230 0xe6 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + + /* 231 0xe7 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 232 0xe8 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 233 0xe9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 234 0xea '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0xee, /* 11101110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 235 0xeb '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1e, /* 00011110 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x3e, /* 00111110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 236 0xec '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 237 0xed '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x03, /* 00000011 */ + 0x06, /* 00000110 */ + 0x7e, /* 01111110 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0xf3, /* 11110011 */ + 0x7e, /* 01111110 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 238 0xee '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1c, /* 00011100 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x7c, /* 01111100 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x1c, /* 00011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 239 0xef '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 240 0xf0 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 241 0xf1 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 242 0xf2 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 243 0xf3 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 244 0xf4 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x0e, /* 00001110 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 245 0xf5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 246 0xf6 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 247 0xf7 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 248 0xf8 '�' */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 249 0xf9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 250 0xfa '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 251 0xfb '�' */ + 0x00, /* 00000000 */ + 0x0f, /* 00001111 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0xec, /* 11101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x3c, /* 00111100 */ + 0x1c, /* 00011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 252 0xfc '�' */ + 0x00, /* 00000000 */ + 0x6c, /* 01101100 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 253 0xfd '�' */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x32, /* 00110010 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 254 0xfe '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 255 0xff '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + +}; diff --git a/kernel/graphics/fonts/font_8x8.h b/kernel/graphics/fonts/font_8x8.h new file mode 100644 index 0000000..2039426 --- /dev/null +++ b/kernel/graphics/fonts/font_8x8.h @@ -0,0 +1,2570 @@ + +/**********************************************/ +/* */ +/* Font file generated by cpi2fnt */ +/* */ +/**********************************************/ + +static const unsigned char fontdata_8x8[] = { + + /* 0 0x00 '^@' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 1 0x01 '^A' */ + 0x7e, /* 01111110 */ + 0x81, /* 10000001 */ + 0xa5, /* 10100101 */ + 0x81, /* 10000001 */ + 0xbd, /* 10111101 */ + 0x99, /* 10011001 */ + 0x81, /* 10000001 */ + 0x7e, /* 01111110 */ + + /* 2 0x02 '^B' */ + 0x7e, /* 01111110 */ + 0xff, /* 11111111 */ + 0xdb, /* 11011011 */ + 0xff, /* 11111111 */ + 0xc3, /* 11000011 */ + 0xe7, /* 11100111 */ + 0xff, /* 11111111 */ + 0x7e, /* 01111110 */ + + /* 3 0x03 '^C' */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + + /* 4 0x04 '^D' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + + /* 5 0x05 '^E' */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xd6, /* 11010110 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + + /* 6 0x06 '^F' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + + /* 7 0x07 '^G' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 8 0x08 '^H' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xe7, /* 11100111 */ + 0xc3, /* 11000011 */ + 0xc3, /* 11000011 */ + 0xe7, /* 11100111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 9 0x09 '^I' */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x42, /* 01000010 */ + 0x42, /* 01000010 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 10 0x0a '^J' */ + 0xff, /* 11111111 */ + 0xc3, /* 11000011 */ + 0x99, /* 10011001 */ + 0xbd, /* 10111101 */ + 0xbd, /* 10111101 */ + 0x99, /* 10011001 */ + 0xc3, /* 11000011 */ + 0xff, /* 11111111 */ + + /* 11 0x0b '^K' */ + 0x0f, /* 00001111 */ + 0x07, /* 00000111 */ + 0x0f, /* 00001111 */ + 0x7d, /* 01111101 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x78, /* 01111000 */ + + /* 12 0x0c '^L' */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + + /* 13 0x0d '^M' */ + 0x3f, /* 00111111 */ + 0x33, /* 00110011 */ + 0x3f, /* 00111111 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x70, /* 01110000 */ + 0xf0, /* 11110000 */ + 0xe0, /* 11100000 */ + + /* 14 0x0e '^N' */ + 0x7f, /* 01111111 */ + 0x63, /* 01100011 */ + 0x7f, /* 01111111 */ + 0x63, /* 01100011 */ + 0x63, /* 01100011 */ + 0x67, /* 01100111 */ + 0xe6, /* 11100110 */ + 0xc0, /* 11000000 */ + + /* 15 0x0f '^O' */ + 0x18, /* 00011000 */ + 0xdb, /* 11011011 */ + 0x3c, /* 00111100 */ + 0xe7, /* 11100111 */ + 0xe7, /* 11100111 */ + 0x3c, /* 00111100 */ + 0xdb, /* 11011011 */ + 0x18, /* 00011000 */ + + /* 16 0x10 '^P' */ + 0x80, /* 10000000 */ + 0xe0, /* 11100000 */ + 0xf8, /* 11111000 */ + 0xfe, /* 11111110 */ + 0xf8, /* 11111000 */ + 0xe0, /* 11100000 */ + 0x80, /* 10000000 */ + 0x00, /* 00000000 */ + + /* 17 0x11 '^Q' */ + 0x02, /* 00000010 */ + 0x0e, /* 00001110 */ + 0x3e, /* 00111110 */ + 0xfe, /* 11111110 */ + 0x3e, /* 00111110 */ + 0x0e, /* 00001110 */ + 0x02, /* 00000010 */ + 0x00, /* 00000000 */ + + /* 18 0x12 '^R' */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + + /* 19 0x13 '^S' */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + + /* 20 0x14 '^T' */ + 0x7f, /* 01111111 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0x7b, /* 01111011 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x00, /* 00000000 */ + + /* 21 0x15 '^U' */ + 0x3e, /* 00111110 */ + 0x61, /* 01100001 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x86, /* 10000110 */ + 0x7c, /* 01111100 */ + + /* 22 0x16 '^V' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 23 0x17 '^W' */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + + /* 24 0x18 '^X' */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 25 0x19 '^Y' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 26 0x1a '^Z' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0xfe, /* 11111110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 27 0x1b '^[' */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xfe, /* 11111110 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 28 0x1c '^\' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 29 0x1d '^]' */ + 0x00, /* 00000000 */ + 0x24, /* 00100100 */ + 0x66, /* 01100110 */ + 0xff, /* 11111111 */ + 0x66, /* 01100110 */ + 0x24, /* 00100100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 30 0x1e '^^' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 31 0x1f '^_' */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 32 0x20 ' ' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 33 0x21 '!' */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 34 0x22 '"' */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x24, /* 00100100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 35 0x23 '#' */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + + /* 36 0x24 '$' */ + 0x18, /* 00011000 */ + 0x3e, /* 00111110 */ + 0x60, /* 01100000 */ + 0x3c, /* 00111100 */ + 0x06, /* 00000110 */ + 0x7c, /* 01111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 37 0x25 '%' */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xcc, /* 11001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x66, /* 01100110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 38 0x26 '&' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 39 0x27 ''' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 40 0x28 '(' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + + /* 41 0x29 ')' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + + /* 42 0x2a '*' */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0xff, /* 11111111 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 43 0x2b '+' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 44 0x2c ',' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + + /* 45 0x2d '-' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 46 0x2e '.' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 47 0x2f '/' */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0x80, /* 10000000 */ + 0x00, /* 00000000 */ + + /* 48 0x30 '0' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 49 0x31 '1' */ + 0x18, /* 00011000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 50 0x32 '2' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x06, /* 00000110 */ + 0x1c, /* 00011100 */ + 0x30, /* 00110000 */ + 0x66, /* 01100110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 51 0x33 '3' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x06, /* 00000110 */ + 0x3c, /* 00111100 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 52 0x34 '4' */ + 0x1c, /* 00011100 */ + 0x3c, /* 00111100 */ + 0x6c, /* 01101100 */ + 0xcc, /* 11001100 */ + 0xfe, /* 11111110 */ + 0x0c, /* 00001100 */ + 0x1e, /* 00011110 */ + 0x00, /* 00000000 */ + + /* 53 0x35 '5' */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfc, /* 11111100 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 54 0x36 '6' */ + 0x38, /* 00111000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 55 0x37 '7' */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + + /* 56 0x38 '8' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 57 0x39 '9' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + + /* 58 0x3a ':' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 59 0x3b ';' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + + /* 60 0x3c '<' */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + + /* 61 0x3d '=' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 62 0x3e '>' */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + + /* 63 0x3f '?' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 64 0x40 '@' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xde, /* 11011110 */ + 0xde, /* 11011110 */ + 0xde, /* 11011110 */ + 0xc0, /* 11000000 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + + /* 65 0x41 'A' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 66 0x42 'B' */ + 0xfc, /* 11111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + + /* 67 0x43 'C' */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 68 0x44 'D' */ + 0xf8, /* 11111000 */ + 0x6c, /* 01101100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x6c, /* 01101100 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + + /* 69 0x45 'E' */ + 0xfe, /* 11111110 */ + 0x62, /* 01100010 */ + 0x68, /* 01101000 */ + 0x78, /* 01111000 */ + 0x68, /* 01101000 */ + 0x62, /* 01100010 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 70 0x46 'F' */ + 0xfe, /* 11111110 */ + 0x62, /* 01100010 */ + 0x68, /* 01101000 */ + 0x78, /* 01111000 */ + 0x68, /* 01101000 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x00, /* 00000000 */ + + /* 71 0x47 'G' */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xce, /* 11001110 */ + 0x66, /* 01100110 */ + 0x3a, /* 00111010 */ + 0x00, /* 00000000 */ + + /* 72 0x48 'H' */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 73 0x49 'I' */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 74 0x4a 'J' */ + 0x1e, /* 00011110 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x78, /* 01111000 */ + 0x00, /* 00000000 */ + + /* 75 0x4b 'K' */ + 0xe6, /* 11100110 */ + 0x66, /* 01100110 */ + 0x6c, /* 01101100 */ + 0x78, /* 01111000 */ + 0x6c, /* 01101100 */ + 0x66, /* 01100110 */ + 0xe6, /* 11100110 */ + 0x00, /* 00000000 */ + + /* 76 0x4c 'L' */ + 0xf0, /* 11110000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x62, /* 01100010 */ + 0x66, /* 01100110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 77 0x4d 'M' */ + 0xc6, /* 11000110 */ + 0xee, /* 11101110 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xd6, /* 11010110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 78 0x4e 'N' */ + 0xc6, /* 11000110 */ + 0xe6, /* 11100110 */ + 0xf6, /* 11110110 */ + 0xde, /* 11011110 */ + 0xce, /* 11001110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 79 0x4f 'O' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 80 0x50 'P' */ + 0xfc, /* 11111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x00, /* 00000000 */ + + /* 81 0x51 'Q' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xce, /* 11001110 */ + 0x7c, /* 01111100 */ + 0x0e, /* 00001110 */ + + /* 82 0x52 'R' */ + 0xfc, /* 11111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x6c, /* 01101100 */ + 0x66, /* 01100110 */ + 0xe6, /* 11100110 */ + 0x00, /* 00000000 */ + + /* 83 0x53 'S' */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 84 0x54 'T' */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x5a, /* 01011010 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 85 0x55 'U' */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 86 0x56 'V' */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 87 0x57 'W' */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + + /* 88 0x58 'X' */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 89 0x59 'Y' */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 90 0x5a 'Z' */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x8c, /* 10001100 */ + 0x18, /* 00011000 */ + 0x32, /* 00110010 */ + 0x66, /* 01100110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 91 0x5b '[' */ + 0x3c, /* 00111100 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 92 0x5c '\' */ + 0xc0, /* 11000000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x06, /* 00000110 */ + 0x02, /* 00000010 */ + 0x00, /* 00000000 */ + + /* 93 0x5d ']' */ + 0x3c, /* 00111100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 94 0x5e '^' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 95 0x5f '_' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + + /* 96 0x60 '`' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 97 0x61 'a' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 98 0x62 'b' */ + 0xe0, /* 11100000 */ + 0x60, /* 01100000 */ + 0x7c, /* 01111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + + /* 99 0x63 'c' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 100 0x64 'd' */ + 0x1c, /* 00011100 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 101 0x65 'e' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 102 0x66 'f' */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x60, /* 01100000 */ + 0xf8, /* 11111000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x00, /* 00000000 */ + + /* 103 0x67 'g' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x7c, /* 01111100 */ + 0x0c, /* 00001100 */ + 0xf8, /* 11111000 */ + + /* 104 0x68 'h' */ + 0xe0, /* 11100000 */ + 0x60, /* 01100000 */ + 0x6c, /* 01101100 */ + 0x76, /* 01110110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0xe6, /* 11100110 */ + 0x00, /* 00000000 */ + + /* 105 0x69 'i' */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 106 0x6a 'j' */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + + /* 107 0x6b 'k' */ + 0xe0, /* 11100000 */ + 0x60, /* 01100000 */ + 0x66, /* 01100110 */ + 0x6c, /* 01101100 */ + 0x78, /* 01111000 */ + 0x6c, /* 01101100 */ + 0xe6, /* 11100110 */ + 0x00, /* 00000000 */ + + /* 108 0x6c 'l' */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 109 0x6d 'm' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xec, /* 11101100 */ + 0xfe, /* 11111110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0x00, /* 00000000 */ + + /* 110 0x6e 'n' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + + /* 111 0x6f 'o' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 112 0x70 'p' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + + /* 113 0x71 'q' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x7c, /* 01111100 */ + 0x0c, /* 00001100 */ + 0x1e, /* 00011110 */ + + /* 114 0x72 'r' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x76, /* 01110110 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x00, /* 00000000 */ + + /* 115 0x73 's' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x06, /* 00000110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + + /* 116 0x74 't' */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0xfc, /* 11111100 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x36, /* 00110110 */ + 0x1c, /* 00011100 */ + 0x00, /* 00000000 */ + + /* 117 0x75 'u' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 118 0x76 'v' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 119 0x77 'w' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xd6, /* 11010110 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + + /* 120 0x78 'x' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 121 0x79 'y' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0xfc, /* 11111100 */ + + /* 122 0x7a 'z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x4c, /* 01001100 */ + 0x18, /* 00011000 */ + 0x32, /* 00110010 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 123 0x7b '{' */ + 0x0e, /* 00001110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x70, /* 01110000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x0e, /* 00001110 */ + 0x00, /* 00000000 */ + + /* 124 0x7c '|' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 125 0x7d '}' */ + 0x70, /* 01110000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x0e, /* 00001110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + + /* 126 0x7e '~' */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 127 0x7f '' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 128 0x80 '�' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x0c, /* 00001100 */ + 0x78, /* 01111000 */ + + /* 129 0x81 '�' */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 130 0x82 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 131 0x83 '�' */ + 0x7c, /* 01111100 */ + 0x82, /* 10000010 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 132 0x84 '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 133 0x85 '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 134 0x86 '�' */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 135 0x87 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x7e, /* 01111110 */ + 0x0c, /* 00001100 */ + 0x38, /* 00111000 */ + + /* 136 0x88 '�' */ + 0x7c, /* 01111100 */ + 0x82, /* 10000010 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 137 0x89 '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 138 0x8a '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 139 0x8b '�' */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 140 0x8c '�' */ + 0x7c, /* 01111100 */ + 0x82, /* 10000010 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 141 0x8d '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 142 0x8e '�' */ + 0xc6, /* 11000110 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 143 0x8f '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 144 0x90 '�' */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xf8, /* 11111000 */ + 0xc0, /* 11000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 145 0x91 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0xd8, /* 11011000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 146 0x92 '�' */ + 0x3e, /* 00111110 */ + 0x6c, /* 01101100 */ + 0xcc, /* 11001100 */ + 0xfe, /* 11111110 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xce, /* 11001110 */ + 0x00, /* 00000000 */ + + /* 147 0x93 '�' */ + 0x7c, /* 01111100 */ + 0x82, /* 10000010 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 148 0x94 '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 149 0x95 '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 150 0x96 '�' */ + 0x78, /* 01111000 */ + 0x84, /* 10000100 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 151 0x97 '�' */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 152 0x98 '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0xfc, /* 11111100 */ + + /* 153 0x99 '�' */ + 0xc6, /* 11000110 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 154 0x9a '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 155 0x9b '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 156 0x9c '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x64, /* 01100100 */ + 0xf0, /* 11110000 */ + 0x60, /* 01100000 */ + 0x66, /* 01100110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + + /* 157 0x9d '�' */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 158 0x9e '�' */ + 0xf8, /* 11111000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xfa, /* 11111010 */ + 0xc6, /* 11000110 */ + 0xcf, /* 11001111 */ + 0xc6, /* 11000110 */ + 0xc7, /* 11000111 */ + + /* 159 0x9f '�' */ + 0x0e, /* 00001110 */ + 0x1b, /* 00011011 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + + /* 160 0xa0 '�' */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 161 0xa1 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 162 0xa2 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 163 0xa3 '�' */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 164 0xa4 '�' */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + + /* 165 0xa5 '�' */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0xe6, /* 11100110 */ + 0xf6, /* 11110110 */ + 0xde, /* 11011110 */ + 0xce, /* 11001110 */ + 0x00, /* 00000000 */ + + /* 166 0xa6 '�' */ + 0x3c, /* 00111100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x3e, /* 00111110 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 167 0xa7 '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 168 0xa8 '�' */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x63, /* 01100011 */ + 0x3e, /* 00111110 */ + 0x00, /* 00000000 */ + + /* 169 0xa9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 170 0xaa '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 171 0xab '�' */ + 0x63, /* 01100011 */ + 0xe6, /* 11100110 */ + 0x6c, /* 01101100 */ + 0x7e, /* 01111110 */ + 0x33, /* 00110011 */ + 0x66, /* 01100110 */ + 0xcc, /* 11001100 */ + 0x0f, /* 00001111 */ + + /* 172 0xac '�' */ + 0x63, /* 01100011 */ + 0xe6, /* 11100110 */ + 0x6c, /* 01101100 */ + 0x7a, /* 01111010 */ + 0x36, /* 00110110 */ + 0x6a, /* 01101010 */ + 0xdf, /* 11011111 */ + 0x06, /* 00000110 */ + + /* 173 0xad '�' */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 174 0xae '�' */ + 0x00, /* 00000000 */ + 0x33, /* 00110011 */ + 0x66, /* 01100110 */ + 0xcc, /* 11001100 */ + 0x66, /* 01100110 */ + 0x33, /* 00110011 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 175 0xaf '�' */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0x66, /* 01100110 */ + 0x33, /* 00110011 */ + 0x66, /* 01100110 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 176 0xb0 '�' */ + 0x22, /* 00100010 */ + 0x88, /* 10001000 */ + 0x22, /* 00100010 */ + 0x88, /* 10001000 */ + 0x22, /* 00100010 */ + 0x88, /* 10001000 */ + 0x22, /* 00100010 */ + 0x88, /* 10001000 */ + + /* 177 0xb1 '�' */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + + /* 178 0xb2 '�' */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + + /* 179 0xb3 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 180 0xb4 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 181 0xb5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 182 0xb6 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 183 0xb7 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 184 0xb8 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 185 0xb9 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x06, /* 00000110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 186 0xba '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 187 0xbb '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x06, /* 00000110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 188 0xbc '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x06, /* 00000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 189 0xbd '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 190 0xbe '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 191 0xbf '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 192 0xc0 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 193 0xc1 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 194 0xc2 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 195 0xc3 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 196 0xc4 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 197 0xc5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 198 0xc6 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 199 0xc7 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 200 0xc8 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x30, /* 00110000 */ + 0x3f, /* 00111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 201 0xc9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3f, /* 00111111 */ + 0x30, /* 00110000 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 202 0xca '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf7, /* 11110111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 203 0xcb '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xf7, /* 11110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 204 0xcc '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x30, /* 00110000 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 205 0xcd '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 206 0xce '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf7, /* 11110111 */ + 0x00, /* 00000000 */ + 0xf7, /* 11110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 207 0xcf '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 208 0xd0 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 209 0xd1 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 210 0xd2 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 211 0xd3 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x3f, /* 00111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 212 0xd4 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 213 0xd5 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 214 0xd6 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3f, /* 00111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 215 0xd7 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xff, /* 11111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 216 0xd8 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 217 0xd9 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 218 0xda '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 219 0xdb '�' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 220 0xdc '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 221 0xdd '�' */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + + /* 222 0xde '�' */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + + /* 223 0xdf '�' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 224 0xe0 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0xc8, /* 11001000 */ + 0xdc, /* 11011100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 225 0xe1 '�' */ + 0x78, /* 01111000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xd8, /* 11011000 */ + 0xcc, /* 11001100 */ + 0xc6, /* 11000110 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + + /* 226 0xe2 '�' */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + + /* 227 0xe3 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + + /* 228 0xe4 '�' */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 229 0xe5 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + + /* 230 0xe6 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0xc0, /* 11000000 */ + + /* 231 0xe7 '�' */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 232 0xe8 '�' */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + + /* 233 0xe9 '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 234 0xea '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0xee, /* 11101110 */ + 0x00, /* 00000000 */ + + /* 235 0xeb '�' */ + 0x0e, /* 00001110 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x3e, /* 00111110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 236 0xec '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 237 0xed '�' */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x7e, /* 01111110 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0x7e, /* 01111110 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + + /* 238 0xee '�' */ + 0x1e, /* 00011110 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x7e, /* 01111110 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x1e, /* 00011110 */ + 0x00, /* 00000000 */ + + /* 239 0xef '�' */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 240 0xf0 '�' */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 241 0xf1 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 242 0xf2 '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 243 0xf3 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 244 0xf4 '�' */ + 0x0e, /* 00001110 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 245 0xf5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + + /* 246 0xf6 '�' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 247 0xf7 '�' */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 248 0xf8 '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 249 0xf9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 250 0xfa '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 251 0xfb '�' */ + 0x0f, /* 00001111 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0xec, /* 11101100 */ + 0x6c, /* 01101100 */ + 0x3c, /* 00111100 */ + 0x1c, /* 00011100 */ + + /* 252 0xfc '�' */ + 0x6c, /* 01101100 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 253 0xfd '�' */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 254 0xfe '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 255 0xff '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + +}; diff --git a/kernel/graphics/fonts/font_acorn_8x8.h b/kernel/graphics/fonts/font_acorn_8x8.h new file mode 100644 index 0000000..d69948c --- /dev/null +++ b/kernel/graphics/fonts/font_acorn_8x8.h @@ -0,0 +1,260 @@ + +/* Acorn-like font definition, with PC graphics characters */ + +static const unsigned char acorndata_8x8[] = { + /* 00 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ^@ */ + /* 01 */ 0x7e, 0x81, 0xa5, 0x81, 0xbd, 0x99, 0x81, 0x7e, /* ^A */ + /* 02 */ 0x7e, 0xff, 0xbd, 0xff, 0xc3, 0xe7, 0xff, 0x7e, /* ^B */ + /* 03 */ 0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, /* ^C */ + /* 04 */ 0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00, /* ^D */ + /* 05 */ 0x00, 0x18, 0x3c, 0xe7, 0xe7, 0x3c, 0x18, 0x00, /* ^E */ + /* 06 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 07 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 08 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 09 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 0A */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 0B */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 0C */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 0D */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 0E */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 0F */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 10 */ 0x00, 0x60, 0x78, 0x7e, 0x7e, 0x78, 0x60, 0x00, /* |> */ + /* 11 */ 0x00, 0x06, 0x1e, 0x7e, 0x7e, 0x1e, 0x06, 0x00, /* <| */ + /* 12 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 13 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 14 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 15 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 16 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 17 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 18 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 19 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 1A */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 1B */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 1C */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 1D */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 1E */ 0x00, 0x18, 0x18, 0x3c, 0x3c, 0x7e, 0x7e, 0x00, /* /\ */ + /* 1F */ 0x00, 0x7e, 0x7e, 0x3c, 0x3c, 0x18, 0x18, 0x00, /* \/ */ + /* 20 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* */ + /* 21 */ 0x18, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x18, 0x00, /* ! */ + /* 22 */ 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, /* " */ + /* 23 */ 0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36, 0x00, /* # */ + /* 24 */ 0x0C, 0x3F, 0x68, 0x3E, 0x0B, 0x7E, 0x18, 0x00, /* $ */ + /* 25 */ 0x60, 0x66, 0x0C, 0x18, 0x30, 0x66, 0x06, 0x00, /* % */ + /* 26 */ 0x38, 0x6C, 0x6C, 0x38, 0x6D, 0x66, 0x3B, 0x00, /* & */ + /* 27 */ 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, /* ' */ + /* 28 */ 0x0C, 0x18, 0x30, 0x30, 0x30, 0x18, 0x0C, 0x00, /* ( */ + /* 29 */ 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x18, 0x30, 0x00, /* ) */ + /* 2A */ 0x00, 0x18, 0x7E, 0x3C, 0x7E, 0x18, 0x00, 0x00, /* * */ + /* 2B */ 0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, /* + */ + /* 2C */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, /* , */ + /* 2D */ 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, /* - */ + /* 2E */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, /* . */ + /* 2F */ 0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00, 0x00, /* / */ + /* 30 */ 0x3C, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x3C, 0x00, /* 0 */ + /* 31 */ 0x18, 0x38, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00, /* 1 */ + /* 32 */ 0x3C, 0x66, 0x06, 0x0C, 0x18, 0x30, 0x7E, 0x00, /* 2 */ + /* 33 */ 0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C, 0x00, /* 3 */ + /* 34 */ 0x0C, 0x1C, 0x3C, 0x6C, 0x7E, 0x0C, 0x0C, 0x00, /* 4 */ + /* 35 */ 0x7E, 0x60, 0x7C, 0x06, 0x06, 0x66, 0x3C, 0x00, /* 5 */ + /* 36 */ 0x1C, 0x30, 0x60, 0x7C, 0x66, 0x66, 0x3C, 0x00, /* 6 */ + /* 37 */ 0x7E, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00, /* 7 */ + /* 38 */ 0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00, /* 8 */ + /* 39 */ 0x3C, 0x66, 0x66, 0x3E, 0x06, 0x0C, 0x38, 0x00, /* 9 */ + /* 3A */ 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, /* : */ + /* 3B */ 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30, /* ; */ + /* 3C */ 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x00, /* < */ + /* 3D */ 0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00, /* = */ + /* 3E */ 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x00, /* > */ + /* 3F */ 0x3C, 0x66, 0x0C, 0x18, 0x18, 0x00, 0x18, 0x00, /* ? */ + /* 40 */ 0x3C, 0x66, 0x6E, 0x6A, 0x6E, 0x60, 0x3C, 0x00, /* @ */ + /* 41 */ 0x3C, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00, /* A */ + /* 42 */ 0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x7C, 0x00, /* B */ + /* 43 */ 0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x00, /* C */ + /* 44 */ 0x78, 0x6C, 0x66, 0x66, 0x66, 0x6C, 0x78, 0x00, /* D */ + /* 45 */ 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E, 0x00, /* E */ + /* 46 */ 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x60, 0x00, /* F */ + /* 47 */ 0x3C, 0x66, 0x60, 0x6E, 0x66, 0x66, 0x3C, 0x00, /* G */ + /* 48 */ 0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00, /* H */ + /* 49 */ 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00, /* I */ + /* 4A */ 0x3E, 0x0C, 0x0C, 0x0C, 0x0C, 0x6C, 0x38, 0x00, /* J */ + /* 4B */ 0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66, 0x00, /* K */ + /* 4C */ 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7E, 0x00, /* L */ + /* 4D */ 0x63, 0x77, 0x7F, 0x6B, 0x6B, 0x63, 0x63, 0x00, /* M */ + /* 4E */ 0x66, 0x66, 0x76, 0x7E, 0x6E, 0x66, 0x66, 0x00, /* N */ + /* 4F */ 0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, /* O */ + /* 50 */ 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x60, 0x00, /* P */ + /* 51 */ 0x3C, 0x66, 0x66, 0x66, 0x6A, 0x6C, 0x36, 0x00, /* Q */ + /* 52 */ 0x7C, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0x66, 0x00, /* R */ + /* 53 */ 0x3C, 0x66, 0x60, 0x3C, 0x06, 0x66, 0x3C, 0x00, /* S */ + /* 54 */ 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, /* T */ + /* 55 */ 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, /* U */ + /* 56 */ 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, /* V */ + /* 57 */ 0x63, 0x63, 0x6B, 0x6B, 0x7F, 0x77, 0x63, 0x00, /* W */ + /* 58 */ 0x66, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x66, 0x00, /* X */ + /* 59 */ 0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x00, /* Y */ + /* 5A */ 0x7E, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x7E, 0x00, /* Z */ + /* 5B */ 0x7C, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7C, 0x00, /* [ */ + /* 5C */ 0x00, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x00, /* \ */ + /* 5D */ 0x3E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x3E, 0x00, /* ] */ + /* 5E */ 0x3C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ^ */ + /* 5F */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, /* _ */ + /* 60 */ 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* */ + /* 61 */ 0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x3E, 0x00, /* a */ + /* 62 */ 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x7C, 0x00, /* b */ + /* 63 */ 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x00, /* c */ + /* 64 */ 0x06, 0x06, 0x3E, 0x66, 0x66, 0x66, 0x3E, 0x00, /* d */ + /* 65 */ 0x00, 0x00, 0x3C, 0x66, 0x7E, 0x60, 0x3C, 0x00, /* e */ + /* 66 */ 0x1C, 0x30, 0x30, 0x7C, 0x30, 0x30, 0x30, 0x00, /* f */ + /* 67 */ 0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x3C, /* g */ + /* 68 */ 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x00, /* h */ + /* 69 */ 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00, /* i */ + /* 6A */ 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x70, /* j */ + /* 6B */ 0x60, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0x00, /* k */ + /* 6C */ 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, /* l */ + /* 6D */ 0x00, 0x00, 0x36, 0x7F, 0x6B, 0x6B, 0x63, 0x00, /* m */ + /* 6E */ 0x00, 0x00, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x00, /* n */ + /* 6F */ 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00, /* o */ + /* 70 */ 0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60, /* p */ + /* 71 */ 0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x07, /* q */ + /* 72 */ 0x00, 0x00, 0x6C, 0x76, 0x60, 0x60, 0x60, 0x00, /* r */ + /* 73 */ 0x00, 0x00, 0x3E, 0x60, 0x3C, 0x06, 0x7C, 0x00, /* s */ + /* 74 */ 0x30, 0x30, 0x7C, 0x30, 0x30, 0x30, 0x1C, 0x00, /* t */ + /* 75 */ 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3E, 0x00, /* u */ + /* 76 */ 0x00, 0x00, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, /* v */ + /* 77 */ 0x00, 0x00, 0x63, 0x6B, 0x6B, 0x7F, 0x36, 0x00, /* w */ + /* 78 */ 0x00, 0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x00, /* x */ + /* 79 */ 0x00, 0x00, 0x66, 0x66, 0x66, 0x3E, 0x06, 0x3C, /* y */ + /* 7A */ 0x00, 0x00, 0x7E, 0x0C, 0x18, 0x30, 0x7E, 0x00, /* z */ + /* 7B */ 0x0C, 0x18, 0x18, 0x70, 0x18, 0x18, 0x0C, 0x00, /* { */ + /* 7C */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, /* | */ + /* 7D */ 0x30, 0x18, 0x18, 0x0E, 0x18, 0x18, 0x30, 0x00, /* } */ + /* 7E */ 0x31, 0x6B, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, /* ~ */ + /* 7F */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /*  */ + /* 80 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 81 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 82 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 83 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 84 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 85 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 86 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 87 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 88 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 89 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 8A */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 8B */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 8C */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 8D */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 8E */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 8F */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 90 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 91 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 92 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 93 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 94 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 95 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 96 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 97 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 98 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 99 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 9A */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 9B */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 9C */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 9D */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 9E */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 9F */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A2 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A3 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A4 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A5 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A6 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A7 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* A9 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* AA */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* AB */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* AC */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* AD */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* AE */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* AF */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* B0 */ 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, + /* B1 */ 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, + /* B2 */ 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, + /* B3 */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* B4 */ 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, + /* B5 */ 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, + /* B6 */ 0x66, 0x66, 0x66, 0xe6, 0x66, 0x66, 0x66, 0x66, + /* B7 */ 0x00, 0x00, 0x00, 0xfe, 0x66, 0x66, 0x66, 0x66, + /* B8 */ 0x00, 0x00, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, + /* B9 */ 0x66, 0x66, 0xe6, 0x06, 0xe6, 0x66, 0x66, 0x66, + /* BA */ 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + /* BB */ 0x00, 0x00, 0xfe, 0x06, 0xe6, 0x66, 0x66, 0x66, + /* BC */ 0x66, 0x66, 0xe6, 0x06, 0xfe, 0x00, 0x00, 0x00, + /* BD */ 0x66, 0x66, 0x66, 0xfe, 0x00, 0x00, 0x00, 0x00, + /* BE */ 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x00, 0x00, 0x00, + /* BF */ 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18, 0x18, + /* C0 */ 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, + /* C1 */ 0x18, 0x18, 0x18, 0xff, 0x00, 0x00, 0x00, 0x00, + /* C2 */ 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, + /* C3 */ 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, + /* C4 */ 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + /* C5 */ 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, + /* C6 */ 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, + /* C7 */ 0x66, 0x66, 0x66, 0x67, 0x66, 0x66, 0x66, 0x66, + /* C8 */ 0x66, 0x66, 0x67, 0x60, 0x7f, 0x00, 0x00, 0x00, + /* C9 */ 0x00, 0x00, 0x7f, 0x60, 0x67, 0x66, 0x66, 0x66, + /* CA */ 0x66, 0x66, 0xe7, 0x00, 0xff, 0x00, 0x00, 0x00, + /* CB */ 0x00, 0x00, 0xff, 0x00, 0xe7, 0x66, 0x66, 0x66, + /* CC */ 0x66, 0x66, 0x67, 0x60, 0x67, 0x66, 0x66, 0x66, + /* CD */ 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, + /* CE */ 0x66, 0x66, 0xe7, 0x00, 0xe7, 0x66, 0x66, 0x66, + /* CF */ 0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, + /* D0 */ 0x66, 0x66, 0x66, 0xff, 0x00, 0x00, 0x00, 0x00, + /* D1 */ 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18, + /* D2 */ 0x00, 0x00, 0x00, 0xff, 0x66, 0x66, 0x66, 0x66, + /* D3 */ 0x66, 0x66, 0x66, 0x7f, 0x00, 0x00, 0x00, 0x00, + /* D4 */ 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00, + /* D5 */ 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, + /* D6 */ 0x00, 0x00, 0x00, 0x7f, 0x66, 0x66, 0x66, 0x66, + /* D7 */ 0x66, 0x66, 0x66, 0xff, 0x66, 0x66, 0x66, 0x66, + /* D8 */ 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, + /* D9 */ 0x18, 0x18, 0x18, 0xf8, 0x00, 0x00, 0x00, 0x00, + /* DA */ 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18, 0x18, + /* DB */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /* DC */ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + /* DD */ 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, + /* DE */ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + /* DF */ 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + /* E0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E2 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E3 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E4 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E5 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E6 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E7 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* E9 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* EA */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* EB */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* EC */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* ED */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* EE */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* EF */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F2 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F3 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F4 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F5 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F6 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F7 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* F9 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* FA */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* FB */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* FC */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* FD */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* FE */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* FF */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; diff --git a/kernel/graphics/fonts/font_mini_4x6.h b/kernel/graphics/fonts/font_mini_4x6.h new file mode 100644 index 0000000..3c87e92 --- /dev/null +++ b/kernel/graphics/fonts/font_mini_4x6.h @@ -0,0 +1,2094 @@ + +/* Hand composed "Minuscule" 4x6 font, with binary data generated using + * Perl stub. + * + * Use 'perl -x mini_4x6.c < mini_4x6.c > new_version.c' to regenerate + * binary data. + * + * Created by Kenneth Albanowski. + * No rights reserved, released to the public domain. + * + * Version 1.0 + */ + +/* + +#!/usr/bin/env perl -pn + +s{((0x)?[0-9a-fA-F]+)(.*\[([\*\ ]{4})\])}{ + +($num,$pat,$bits) = ($1,$3,$4); + +$bits =~ s/([^\s0])|(.)/ defined($1) + 0 /ge; + +$num = ord(pack("B8", $bits)); +$num |= $num >> 4; +$num = sprintf("0x%.2x", $num); + +#print "$num,$pat,$bits\n"; + +$num . $pat; +}ge; + +__END__; +*/ + +/* Note: binary data consists of one byte for each row of each character top +to bottom, character 0 to character 255, six bytes per character. Each +byte contains the same four character bits in both nybbles. +MSBit to LSBit = left to right. +*/ + +static const unsigned char fontdata_mini_4x6[] = { + + /*{*/ /* Char 0: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 1: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 2: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 3: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 4: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 5: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 6: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 7: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 8: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 9: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 10: '' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 11: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 12: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 13: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 14: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 15: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 16: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ + /* Char 17: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 18: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 19: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 20: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 21: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 22: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 23: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 24: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 25: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 26: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 27: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 28: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 29: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 30: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 31: ' ' */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 32: ' ' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 33: '!' */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 34: '"' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 35: '#' */ + 0xaa, /*= [* * ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 36: '$' */ + 0x44, /*= [ * ] */ + 0x66, /*= [ ** ] */ + 0xee, /*= [*** ] */ + 0xcc, /*= [** ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 37: '%' */ + 0xaa, /*= [* * ] */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 38: '&' */ + 0x66, /*= [ ** ] */ + 0x99, /*= [* *] */ + 0x66, /*= [ ** ] */ + 0xaa, /*= [* * ] */ + 0xdd, /*= [** *] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 39: ''' */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 40: '(' */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 41: ')' */ + 0x44, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ + /* Char 42: '*' */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 43: '+' */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 44: ',' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 45: '-' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 46: '.' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 47: '/' */ + 0x00, /*= [ ] */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 48: '0' */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 49: '1' */ + 0x44, /*= [ * ] */ + 0xcc, /*= [** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 50: '2' */ + 0xcc, /*= [** ] */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 51: '3' */ + 0xee, /*= [*** ] */ + 0x22, /*= [ * ] */ + 0x66, /*= [ ** ] */ + 0x22, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 52: '4' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 53: '5' */ + 0xee, /*= [*** ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0x22, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 54: '6' */ + 0xee, /*= [*** ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 55: '7' */ + 0xee, /*= [*** ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 56: '8' */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 57: '9' */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 58: ':' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 59: ';' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + /*}*/ + /*{*/ /* Char 60: '<' */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0x44, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 61: '=' */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 62: '>' */ + 0x88, /*= [* ] */ + 0x44, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 63: '?' */ + 0xee, /*= [*** ] */ + 0x22, /*= [ * ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 64: '@' */ + 0x44, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x88, /*= [* ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 65: 'A' */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 66: 'B' */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xcc, /*= [** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 67: 'C' */ + 0x66, /*= [ ** ] */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 68: 'D' */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xcc, /*= [** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 69: 'E' */ + 0xee, /*= [*** ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 70: 'F' */ + 0xee, /*= [*** ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 71: 'G' */ + 0x66, /*= [ ** ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 72: 'H' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 73: 'I' */ + 0xee, /*= [*** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 74: 'J' */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 75: 'K' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 76: 'L' */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 77: 'M' */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 78: 'N' */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 79: 'O' */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 80: 'P' */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xcc, /*= [** ] */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 81: 'Q' */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 82: 'R' */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 83: 'S' */ + 0x66, /*= [ ** ] */ + 0x88, /*= [* ] */ + 0x44, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0xcc, /*= [** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 84: 'T' */ + 0xee, /*= [*** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 85: 'U' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 86: 'V' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 87: 'W' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 88: 'X' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 89: 'Y' */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 90: 'Z' */ + 0xee, /*= [*** ] */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 91: '[' */ + 0x66, /*= [ ** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 92: '\' */ + 0x00, /*= [ ] */ + 0x88, /*= [* ] */ + 0x44, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 93: ']' */ + 0x66, /*= [ ** ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 94: '^' */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 95: '_' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xff, /*= [****] */ + /*}*/ + /*{*/ /* Char 96: '`' */ + 0x88, /*= [* ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 97: 'a' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x66, /*= [ ** ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 98: 'b' */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xcc, /*= [** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 99: 'c' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x66, /*= [ ** ] */ + 0x88, /*= [* ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 100: 'd' */ + 0x22, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x66, /*= [ ** ] */ + 0xaa, /*= [* * ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 101: 'e' */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x88, /*= [* ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 102: 'f' */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 103: 'g' */ + 0x00, /*= [ ] */ + 0x66, /*= [ ** ] */ + 0xaa, /*= [* * ] */ + 0x66, /*= [ ** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 104: 'h' */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 105: 'i' */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 106: 'j' */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 107: 'k' */ + 0x00, /*= [ ] */ + 0x88, /*= [* ] */ + 0xaa, /*= [* * ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 108: 'l' */ + 0x00, /*= [ ] */ + 0xcc, /*= [** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 109: 'm' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 110: 'n' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 111: 'o' */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 112: 'p' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0xcc, /*= [** ] */ + 0x88, /*= [* ] */ + /*}*/ + /*{*/ /* Char 113: 'q' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x66, /*= [ ** ] */ + 0xaa, /*= [* * ] */ + 0x66, /*= [ ** ] */ + 0x22, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 114: 'r' */ + 0x00, /*= [ ] */ + 0xcc, /*= [** ] */ + 0xaa, /*= [* * ] */ + 0x88, /*= [* ] */ + 0x88, /*= [* ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 115: 's' */ + 0x00, /*= [ ] */ + 0x66, /*= [ ** ] */ + 0xcc, /*= [** ] */ + 0x22, /*= [ * ] */ + 0xcc, /*= [** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 116: 't' */ + 0x00, /*= [ ] */ + 0x44, /*= [ * ] */ + 0xee, /*= [*** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 117: 'u' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 118: 'v' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 119: 'w' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 120: 'x' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xaa, /*= [* * ] */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 121: 'y' */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x22, /*= [ * ] */ + 0xcc, /*= [** ] */ + /*}*/ + /*{*/ /* Char 122: 'z' */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0x66, /*= [ ** ] */ + 0xcc, /*= [** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 123: '{' */ + 0x22, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xcc, /*= [** ] */ + 0x44, /*= [ * ] */ + 0x22, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 124: '|' */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 125: '}' */ + 0x88, /*= [* ] */ + 0x44, /*= [ * ] */ + 0x66, /*= [ ** ] */ + 0x44, /*= [ * ] */ + 0x88, /*= [* ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 126: '~' */ + 0x55, /*= [ * *] */ + 0xaa, /*= [* * ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 127: '' */ + 0x44, /*= [ * ] */ + 0xaa, /*= [* * ] */ + 0xaa, /*= [* * ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 128: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 129: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 130: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 131: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 132: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 133: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 134: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 135: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 136: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 137: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 138: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 139: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 140: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 141: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 142: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 143: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 144: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 145: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 146: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 147: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 148: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 149: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 150: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 151: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 152: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 153: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 154: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 155: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 156: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 157: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 158: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 159: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 160: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 161: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 162: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 163: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 164: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 165: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 166: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 167: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 168: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 169: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 170: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 171: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 172: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 173: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 174: */ + 0x00, /*= [ ] */ + 0x66, /*= [ ** ] */ + 0xcc, /*= [** ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 175: */ + 0x00, /*= [ ] */ + 0xcc, /*= [** ] */ + 0x66, /*= [ ** ] */ + 0xcc, /*= [** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 176: */ + 0x88, /*= [* ] */ + 0x22, /*= [ * ] */ + 0x88, /*= [* ] */ + 0x22, /*= [ * ] */ + 0x88, /*= [* ] */ + 0x22, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 177: */ + 0xaa, /*= [* * ] */ + 0x55, /*= [ * *] */ + 0xaa, /*= [* * ] */ + 0x55, /*= [ * *] */ + 0xaa, /*= [* * ] */ + 0x55, /*= [ * *] */ + /*}*/ + /*{*/ /* Char 178: */ + 0xdd, /*= [** *] */ + 0xbb, /*= [* **] */ + 0xdd, /*= [** *] */ + 0xbb, /*= [* **] */ + 0xdd, /*= [** *] */ + 0xbb, /*= [* **] */ + /*}*/ + /*{*/ /* Char 179: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 180: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xcc, /*= [** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 181: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xcc, /*= [** ] */ + 0xcc, /*= [** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 182: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0xee, /*= [*** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 183: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 184: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xcc, /*= [** ] */ + 0xcc, /*= [** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 185: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 186: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 187: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 188: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 189: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 190: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xcc, /*= [** ] */ + 0xcc, /*= [** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 191: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xcc, /*= [** ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 192: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x77, /*= [ ***] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 193: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xff, /*= [****] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 194: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xff, /*= [****] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 195: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x77, /*= [ ***] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 196: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xff, /*= [****] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 197: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xff, /*= [****] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 198: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x77, /*= [ ***] */ + 0x77, /*= [ ***] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 199: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x77, /*= [ ***] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 200: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x77, /*= [ ***] */ + 0x77, /*= [ ***] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 201: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x77, /*= [ ***] */ + 0x77, /*= [ ***] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 202: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 203: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 204: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x77, /*= [ ***] */ + 0x77, /*= [ ***] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 205: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 206: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 207: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 208: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0xff, /*= [****] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 209: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 210: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xff, /*= [****] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 211: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x77, /*= [ ***] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 212: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x77, /*= [ ***] */ + 0x77, /*= [ ***] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 213: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x77, /*= [ ***] */ + 0x77, /*= [ ***] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 214: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x77, /*= [ ***] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 215: */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0xff, /*= [****] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + /*}*/ + /*{*/ /* Char 216: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 217: */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0xcc, /*= [** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 218: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x77, /*= [ ***] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + 0x44, /*= [ * ] */ + /*}*/ + /*{*/ /* Char 219: */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + /*}*/ + /*{*/ /* Char 220: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + /*}*/ + /*{*/ /* Char 221: */ + 0xcc, /*= [** ] */ + 0xcc, /*= [** ] */ + 0xcc, /*= [** ] */ + 0xcc, /*= [** ] */ + 0xcc, /*= [** ] */ + 0xcc, /*= [** ] */ + /*}*/ + /*{*/ /* Char 222: */ + 0x33, /*= [ **] */ + 0x33, /*= [ **] */ + 0x33, /*= [ **] */ + 0x33, /*= [ **] */ + 0x33, /*= [ **] */ + 0x33, /*= [ **] */ + /*}*/ + /*{*/ /* Char 223: */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0xff, /*= [****] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 224: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 225: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 226: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 227: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 228: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 229: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 230: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 231: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 232: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 233: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 234: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 235: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 236: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 237: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 238: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 239: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 240: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 241: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 242: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 243: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 244: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 245: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 246: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 247: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 248: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 249: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 250: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 251: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 252: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 253: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 254: */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + 0x66, /*= [ ** ] */ + 0x66, /*= [ ** ] */ + 0x00, /*= [ ] */ + 0x00, /*= [ ] */ + /*}*/ + /*{*/ /* Char 255: */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0xee, /*= [*** ] */ + 0x00, /*= [ ] */ + /*}*/ +}; diff --git a/kernel/graphics/fonts/font_pearl_8x8.h b/kernel/graphics/fonts/font_pearl_8x8.h new file mode 100644 index 0000000..b866d74 --- /dev/null +++ b/kernel/graphics/fonts/font_pearl_8x8.h @@ -0,0 +1,2575 @@ + +/**********************************************/ +/* */ +/* Font file generated by cpi2fnt */ +/* ------------------------------ */ +/* Combined with the alpha-numeric */ +/* portion of Greg Harp's old PEARL */ +/* font (from earlier versions of */ +/* linux-m86k) by John Shifflett */ +/* */ +/**********************************************/ + +static const unsigned char fontdata_pearl_8x8[] = { + + /* 0 0x00 '^@' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 1 0x01 '^A' */ + 0x7e, /* 01111110 */ + 0x81, /* 10000001 */ + 0xa5, /* 10100101 */ + 0x81, /* 10000001 */ + 0xbd, /* 10111101 */ + 0x99, /* 10011001 */ + 0x81, /* 10000001 */ + 0x7e, /* 01111110 */ + + /* 2 0x02 '^B' */ + 0x7e, /* 01111110 */ + 0xff, /* 11111111 */ + 0xdb, /* 11011011 */ + 0xff, /* 11111111 */ + 0xc3, /* 11000011 */ + 0xe7, /* 11100111 */ + 0xff, /* 11111111 */ + 0x7e, /* 01111110 */ + + /* 3 0x03 '^C' */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + + /* 4 0x04 '^D' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0x10, /* 00010000 */ + 0x00, /* 00000000 */ + + /* 5 0x05 '^E' */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0x38, /* 00111000 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0xd6, /* 11010110 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + + /* 6 0x06 '^F' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x7c, /* 01111100 */ + 0xfe, /* 11111110 */ + 0xfe, /* 11111110 */ + 0x7c, /* 01111100 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + + /* 7 0x07 '^G' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 8 0x08 '^H' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xe7, /* 11100111 */ + 0xc3, /* 11000011 */ + 0xc3, /* 11000011 */ + 0xe7, /* 11100111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 9 0x09 '^I' */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x42, /* 01000010 */ + 0x42, /* 01000010 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 10 0x0a '^J' */ + 0xff, /* 11111111 */ + 0xc3, /* 11000011 */ + 0x99, /* 10011001 */ + 0xbd, /* 10111101 */ + 0xbd, /* 10111101 */ + 0x99, /* 10011001 */ + 0xc3, /* 11000011 */ + 0xff, /* 11111111 */ + + /* 11 0x0b '^K' */ + 0x0f, /* 00001111 */ + 0x07, /* 00000111 */ + 0x0f, /* 00001111 */ + 0x7d, /* 01111101 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x78, /* 01111000 */ + + /* 12 0x0c '^L' */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + + /* 13 0x0d '^M' */ + 0x3f, /* 00111111 */ + 0x33, /* 00110011 */ + 0x3f, /* 00111111 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x70, /* 01110000 */ + 0xf0, /* 11110000 */ + 0xe0, /* 11100000 */ + + /* 14 0x0e '^N' */ + 0x7f, /* 01111111 */ + 0x63, /* 01100011 */ + 0x7f, /* 01111111 */ + 0x63, /* 01100011 */ + 0x63, /* 01100011 */ + 0x67, /* 01100111 */ + 0xe6, /* 11100110 */ + 0xc0, /* 11000000 */ + + /* 15 0x0f '^O' */ + 0x18, /* 00011000 */ + 0xdb, /* 11011011 */ + 0x3c, /* 00111100 */ + 0xe7, /* 11100111 */ + 0xe7, /* 11100111 */ + 0x3c, /* 00111100 */ + 0xdb, /* 11011011 */ + 0x18, /* 00011000 */ + + /* 16 0x10 '^P' */ + 0x80, /* 10000000 */ + 0xe0, /* 11100000 */ + 0xf8, /* 11111000 */ + 0xfe, /* 11111110 */ + 0xf8, /* 11111000 */ + 0xe0, /* 11100000 */ + 0x80, /* 10000000 */ + 0x00, /* 00000000 */ + + /* 17 0x11 '^Q' */ + 0x02, /* 00000010 */ + 0x0e, /* 00001110 */ + 0x3e, /* 00111110 */ + 0xfe, /* 11111110 */ + 0x3e, /* 00111110 */ + 0x0e, /* 00001110 */ + 0x02, /* 00000010 */ + 0x00, /* 00000000 */ + + /* 18 0x12 '^R' */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + + /* 19 0x13 '^S' */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + + /* 20 0x14 '^T' */ + 0x7f, /* 01111111 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0x7b, /* 01111011 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x00, /* 00000000 */ + + /* 21 0x15 '^U' */ + 0x3e, /* 00111110 */ + 0x61, /* 01100001 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x86, /* 10000110 */ + 0x7c, /* 01111100 */ + + /* 22 0x16 '^V' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 23 0x17 '^W' */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + + /* 24 0x18 '^X' */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 25 0x19 '^Y' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 26 0x1a '^Z' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0xfe, /* 11111110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 27 0x1b '^[' */ + 0x00, /* 00000000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xfe, /* 11111110 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 28 0x1c '^\' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 29 0x1d '^]' */ + 0x00, /* 00000000 */ + 0x24, /* 00100100 */ + 0x66, /* 01100110 */ + 0xff, /* 11111111 */ + 0x66, /* 01100110 */ + 0x24, /* 00100100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 30 0x1e '^^' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 31 0x1f '^_' */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x7e, /* 01111110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 32 0x20 ' ' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 33 0x21 '!' */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 34 0x22 '"' */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 35 0x23 '#' */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + + /* 36 0x24 '$' */ + 0x18, /* 00011000 */ + 0x3e, /* 00111110 */ + 0x60, /* 01100000 */ + 0x3c, /* 00111100 */ + 0x06, /* 00000110 */ + 0x7c, /* 01111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 37 0x25 '%' */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xcc, /* 11001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x66, /* 01100110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 38 0x26 '&' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x68, /* 01101000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 39 0x27 ''' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 40 0x28 '(' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + + /* 41 0x29 ')' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + + /* 42 0x2a '*' */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0xff, /* 11111111 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 43 0x2b '+' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 44 0x2c ',' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + + /* 45 0x2d '-' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 46 0x2e '.' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 47 0x2f '/' */ + 0x03, /* 00000011 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + + /* 48 0x30 '0' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xde, /* 11011110 */ + 0xfe, /* 11111110 */ + 0xf6, /* 11110110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 49 0x31 '1' */ + 0x18, /* 00011000 */ + 0x78, /* 01111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 50 0x32 '2' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 51 0x33 '3' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x06, /* 00000110 */ + 0x1c, /* 00011100 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 52 0x34 '4' */ + 0x1c, /* 00011100 */ + 0x3c, /* 00111100 */ + 0x6c, /* 01101100 */ + 0xcc, /* 11001100 */ + 0xfe, /* 11111110 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + + /* 53 0x35 '5' */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xfc, /* 11111100 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 54 0x36 '6' */ + 0x38, /* 00111000 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 55 0x37 '7' */ + 0xfe, /* 11111110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + + /* 56 0x38 '8' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 57 0x39 '9' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 58 0x3a ':' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 59 0x3b ';' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + + /* 60 0x3c '<' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + + /* 61 0x3d '=' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 62 0x3e '>' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + + /* 63 0x3f '?' */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 64 0x40 '@' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xde, /* 11011110 */ + 0xde, /* 11011110 */ + 0xde, /* 11011110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 65 0x41 'A' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 66 0x42 'B' */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + + /* 67 0x43 'C' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 68 0x44 'D' */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + + /* 69 0x45 'E' */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xf8, /* 11111000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 70 0x46 'F' */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xf8, /* 11111000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + + /* 71 0x47 'G' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xce, /* 11001110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 72 0x48 'H' */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 73 0x49 'I' */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 74 0x4a 'J' */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 75 0x4b 'K' */ + 0xc6, /* 11000110 */ + 0xcc, /* 11001100 */ + 0xd8, /* 11011000 */ + 0xf0, /* 11110000 */ + 0xd8, /* 11011000 */ + 0xcc, /* 11001100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 76 0x4c 'L' */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 77 0x4d 'M' */ + 0x82, /* 10000010 */ + 0xc6, /* 11000110 */ + 0xee, /* 11101110 */ + 0xfe, /* 11111110 */ + 0xd6, /* 11010110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 78 0x4e 'N' */ + 0xc6, /* 11000110 */ + 0xe6, /* 11100110 */ + 0xf6, /* 11110110 */ + 0xde, /* 11011110 */ + 0xce, /* 11001110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 79 0x4f 'O' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 80 0x50 'P' */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfc, /* 11111100 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + + /* 81 0x51 'Q' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xf6, /* 11110110 */ + 0xde, /* 11011110 */ + 0x7c, /* 01111100 */ + 0x06, /* 00000110 */ + + /* 82 0x52 'R' */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfc, /* 11111100 */ + 0xd8, /* 11011000 */ + 0xcc, /* 11001100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 83 0x53 'S' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0x60, /* 01100000 */ + 0x38, /* 00111000 */ + 0x0c, /* 00001100 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 84 0x54 'T' */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 85 0x55 'U' */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 86 0x56 'V' */ + 0xc3, /* 11000011 */ + 0xc3, /* 11000011 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 87 0x57 'W' */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xfe, /* 11111110 */ + 0xee, /* 11101110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 88 0x58 'X' */ + 0xc3, /* 11000011 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0xc3, /* 11000011 */ + 0x00, /* 00000000 */ + + /* 89 0x59 'Y' */ + 0xc3, /* 11000011 */ + 0xc3, /* 11000011 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 90 0x5a 'Z' */ + 0xfe, /* 11111110 */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 91 0x5b '[' */ + 0x3c, /* 00111100 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 92 0x5c '\' */ + 0xc0, /* 11000000 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x06, /* 00000110 */ + 0x03, /* 00000011 */ + 0x00, /* 00000000 */ + + /* 93 0x5d ']' */ + 0x3c, /* 00111100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 94 0x5e '^' */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 95 0x5f '_' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + + /* 96 0x60 '`' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 97 0x61 'a' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0x06, /* 00000110 */ + 0x7e, /* 01111110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 98 0x62 'b' */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + + /* 99 0x63 'c' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 100 0x64 'd' */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x7e, /* 01111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 101 0x65 'e' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 102 0x66 'f' */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x60, /* 01100000 */ + 0xf0, /* 11110000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x60, /* 01100000 */ + 0x00, /* 00000000 */ + + /* 103 0x67 'g' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0x7c, /* 01111100 */ + + /* 104 0x68 'h' */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 105 0x69 'i' */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 106 0x6a 'j' */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + + /* 107 0x6b 'k' */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xcc, /* 11001100 */ + 0xd8, /* 11011000 */ + 0xf0, /* 11110000 */ + 0xd8, /* 11011000 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + + /* 108 0x6c 'l' */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 109 0x6d 'm' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xec, /* 11101100 */ + 0xfe, /* 11111110 */ + 0xd6, /* 11010110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 110 0x6e 'n' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 111 0x6f 'o' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 112 0x70 'p' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfc, /* 11111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfc, /* 11111100 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + + /* 113 0x71 'q' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + + /* 114 0x72 'r' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0xe6, /* 11100110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + + /* 115 0x73 's' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x06, /* 00000110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + + /* 116 0x74 't' */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x7c, /* 01111100 */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x36, /* 00110110 */ + 0x1c, /* 00011100 */ + 0x00, /* 00000000 */ + + /* 117 0x75 'u' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 118 0x76 'v' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 119 0x77 'w' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xd6, /* 11010110 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + + /* 120 0x78 'x' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 121 0x79 'y' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xc3, /* 11000011 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + + /* 122 0x7a 'z' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x0c, /* 00001100 */ + 0x38, /* 00111000 */ + 0x60, /* 01100000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 123 0x7b '{' */ + 0x0e, /* 00001110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x70, /* 01110000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x0e, /* 00001110 */ + 0x00, /* 00000000 */ + + /* 124 0x7c '|' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 125 0x7d '}' */ + 0x70, /* 01110000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x0e, /* 00001110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + + /* 126 0x7e '~' */ + 0x72, /* 01110010 */ + 0x9c, /* 10011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 127 0x7f '' */ + 0x00, /* 00000000 */ + 0x10, /* 00010000 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 128 0x80 '�' */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x0c, /* 00001100 */ + 0x78, /* 01111000 */ + + /* 129 0x81 '�' */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 130 0x82 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 131 0x83 '�' */ + 0x7c, /* 01111100 */ + 0x82, /* 10000010 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 132 0x84 '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 133 0x85 '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 134 0x86 '�' */ + 0x30, /* 00110000 */ + 0x30, /* 00110000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 135 0x87 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x7e, /* 01111110 */ + 0x0c, /* 00001100 */ + 0x38, /* 00111000 */ + + /* 136 0x88 '�' */ + 0x7c, /* 01111100 */ + 0x82, /* 10000010 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 137 0x89 '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 138 0x8a '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 139 0x8b '�' */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 140 0x8c '�' */ + 0x7c, /* 01111100 */ + 0x82, /* 10000010 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 141 0x8d '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 142 0x8e '�' */ + 0xc6, /* 11000110 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 143 0x8f '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 144 0x90 '�' */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xf8, /* 11111000 */ + 0xc0, /* 11000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 145 0x91 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0xd8, /* 11011000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 146 0x92 '�' */ + 0x3e, /* 00111110 */ + 0x6c, /* 01101100 */ + 0xcc, /* 11001100 */ + 0xfe, /* 11111110 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xce, /* 11001110 */ + 0x00, /* 00000000 */ + + /* 147 0x93 '�' */ + 0x7c, /* 01111100 */ + 0x82, /* 10000010 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 148 0x94 '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 149 0x95 '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 150 0x96 '�' */ + 0x78, /* 01111000 */ + 0x84, /* 10000100 */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 151 0x97 '�' */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 152 0x98 '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7e, /* 01111110 */ + 0x06, /* 00000110 */ + 0xfc, /* 11111100 */ + + /* 153 0x99 '�' */ + 0xc6, /* 11000110 */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 154 0x9a '�' */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 155 0x9b '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 156 0x9c '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x64, /* 01100100 */ + 0xf0, /* 11110000 */ + 0x60, /* 01100000 */ + 0x66, /* 01100110 */ + 0xfc, /* 11111100 */ + 0x00, /* 00000000 */ + + /* 157 0x9d '�' */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 158 0x9e '�' */ + 0xf8, /* 11111000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xfa, /* 11111010 */ + 0xc6, /* 11000110 */ + 0xcf, /* 11001111 */ + 0xc6, /* 11000110 */ + 0xc7, /* 11000111 */ + + /* 159 0x9f '�' */ + 0x0e, /* 00001110 */ + 0x1b, /* 00011011 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + + /* 160 0xa0 '�' */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x7c, /* 01111100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 161 0xa1 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x38, /* 00111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 162 0xa2 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + + /* 163 0xa3 '�' */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 164 0xa4 '�' */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0xdc, /* 11011100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x00, /* 00000000 */ + + /* 165 0xa5 '�' */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0xe6, /* 11100110 */ + 0xf6, /* 11110110 */ + 0xde, /* 11011110 */ + 0xce, /* 11001110 */ + 0x00, /* 00000000 */ + + /* 166 0xa6 '�' */ + 0x3c, /* 00111100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x3e, /* 00111110 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 167 0xa7 '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 168 0xa8 '�' */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x63, /* 01100011 */ + 0x3e, /* 00111110 */ + 0x00, /* 00000000 */ + + /* 169 0xa9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 170 0xaa '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x06, /* 00000110 */ + 0x06, /* 00000110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 171 0xab '�' */ + 0x63, /* 01100011 */ + 0xe6, /* 11100110 */ + 0x6c, /* 01101100 */ + 0x7e, /* 01111110 */ + 0x33, /* 00110011 */ + 0x66, /* 01100110 */ + 0xcc, /* 11001100 */ + 0x0f, /* 00001111 */ + + /* 172 0xac '�' */ + 0x63, /* 01100011 */ + 0xe6, /* 11100110 */ + 0x6c, /* 01101100 */ + 0x7a, /* 01111010 */ + 0x36, /* 00110110 */ + 0x6a, /* 01101010 */ + 0xdf, /* 11011111 */ + 0x06, /* 00000110 */ + + /* 173 0xad '�' */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 174 0xae '�' */ + 0x00, /* 00000000 */ + 0x33, /* 00110011 */ + 0x66, /* 01100110 */ + 0xcc, /* 11001100 */ + 0x66, /* 01100110 */ + 0x33, /* 00110011 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 175 0xaf '�' */ + 0x00, /* 00000000 */ + 0xcc, /* 11001100 */ + 0x66, /* 01100110 */ + 0x33, /* 00110011 */ + 0x66, /* 01100110 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 176 0xb0 '�' */ + 0x22, /* 00100010 */ + 0x88, /* 10001000 */ + 0x22, /* 00100010 */ + 0x88, /* 10001000 */ + 0x22, /* 00100010 */ + 0x88, /* 10001000 */ + 0x22, /* 00100010 */ + 0x88, /* 10001000 */ + + /* 177 0xb1 '�' */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + 0x55, /* 01010101 */ + 0xaa, /* 10101010 */ + + /* 178 0xb2 '�' */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + 0x77, /* 01110111 */ + 0xdd, /* 11011101 */ + + /* 179 0xb3 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 180 0xb4 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 181 0xb5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 182 0xb6 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 183 0xb7 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 184 0xb8 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 185 0xb9 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x06, /* 00000110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 186 0xba '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 187 0xbb '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x06, /* 00000110 */ + 0xf6, /* 11110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 188 0xbc '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf6, /* 11110110 */ + 0x06, /* 00000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 189 0xbd '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 190 0xbe '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 191 0xbf '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xf8, /* 11111000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 192 0xc0 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 193 0xc1 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 194 0xc2 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 195 0xc3 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 196 0xc4 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 197 0xc5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 198 0xc6 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 199 0xc7 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 200 0xc8 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x30, /* 00110000 */ + 0x3f, /* 00111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 201 0xc9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3f, /* 00111111 */ + 0x30, /* 00110000 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 202 0xca '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf7, /* 11110111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 203 0xcb '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xf7, /* 11110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 204 0xcc '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x37, /* 00110111 */ + 0x30, /* 00110000 */ + 0x37, /* 00110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 205 0xcd '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 206 0xce '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xf7, /* 11110111 */ + 0x00, /* 00000000 */ + 0xf7, /* 11110111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 207 0xcf '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 208 0xd0 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 209 0xd1 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 210 0xd2 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 211 0xd3 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x3f, /* 00111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 212 0xd4 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 213 0xd5 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 214 0xd6 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3f, /* 00111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 215 0xd7 '�' */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0xff, /* 11111111 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + + /* 216 0xd8 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0xff, /* 11111111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 217 0xd9 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xf8, /* 11111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 218 0xda '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x1f, /* 00011111 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 219 0xdb '�' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 220 0xdc '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + + /* 221 0xdd '�' */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + 0xf0, /* 11110000 */ + + /* 222 0xde '�' */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + 0x0f, /* 00001111 */ + + /* 223 0xdf '�' */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0xff, /* 11111111 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 224 0xe0 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0xc8, /* 11001000 */ + 0xdc, /* 11011100 */ + 0x76, /* 01110110 */ + 0x00, /* 00000000 */ + + /* 225 0xe1 '�' */ + 0x78, /* 01111000 */ + 0xcc, /* 11001100 */ + 0xcc, /* 11001100 */ + 0xd8, /* 11011000 */ + 0xcc, /* 11001100 */ + 0xc6, /* 11000110 */ + 0xcc, /* 11001100 */ + 0x00, /* 00000000 */ + + /* 226 0xe2 '�' */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0xc0, /* 11000000 */ + 0x00, /* 00000000 */ + + /* 227 0xe3 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x00, /* 00000000 */ + + /* 228 0xe4 '�' */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + + /* 229 0xe5 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + 0x00, /* 00000000 */ + + /* 230 0xe6 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x7c, /* 01111100 */ + 0xc0, /* 11000000 */ + + /* 231 0xe7 '�' */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + + /* 232 0xe8 '�' */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x3c, /* 00111100 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + + /* 233 0xe9 '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xfe, /* 11111110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + + /* 234 0xea '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0xee, /* 11101110 */ + 0x00, /* 00000000 */ + + /* 235 0xeb '�' */ + 0x0e, /* 00001110 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x3e, /* 00111110 */ + 0x66, /* 01100110 */ + 0x66, /* 01100110 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + + /* 236 0xec '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 237 0xed '�' */ + 0x06, /* 00000110 */ + 0x0c, /* 00001100 */ + 0x7e, /* 01111110 */ + 0xdb, /* 11011011 */ + 0xdb, /* 11011011 */ + 0x7e, /* 01111110 */ + 0x60, /* 01100000 */ + 0xc0, /* 11000000 */ + + /* 238 0xee '�' */ + 0x1e, /* 00011110 */ + 0x30, /* 00110000 */ + 0x60, /* 01100000 */ + 0x7e, /* 01111110 */ + 0x60, /* 01100000 */ + 0x30, /* 00110000 */ + 0x1e, /* 00011110 */ + 0x00, /* 00000000 */ + + /* 239 0xef '�' */ + 0x00, /* 00000000 */ + 0x7c, /* 01111100 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0xc6, /* 11000110 */ + 0x00, /* 00000000 */ + + /* 240 0xf0 '�' */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0xfe, /* 11111110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 241 0xf1 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x7e, /* 01111110 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 242 0xf2 '�' */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 243 0xf3 '�' */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x18, /* 00011000 */ + 0x0c, /* 00001100 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + + /* 244 0xf4 '�' */ + 0x0e, /* 00001110 */ + 0x1b, /* 00011011 */ + 0x1b, /* 00011011 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + + /* 245 0xf5 '�' */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0xd8, /* 11011000 */ + 0xd8, /* 11011000 */ + 0x70, /* 01110000 */ + + /* 246 0xf6 '�' */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x7e, /* 01111110 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 247 0xf7 '�' */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0x76, /* 01110110 */ + 0xdc, /* 11011100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 248 0xf8 '�' */ + 0x38, /* 00111000 */ + 0x6c, /* 01101100 */ + 0x6c, /* 01101100 */ + 0x38, /* 00111000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 249 0xf9 '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 250 0xfa '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x18, /* 00011000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 251 0xfb '�' */ + 0x0f, /* 00001111 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0x0c, /* 00001100 */ + 0xec, /* 11101100 */ + 0x6c, /* 01101100 */ + 0x3c, /* 00111100 */ + 0x1c, /* 00011100 */ + + /* 252 0xfc '�' */ + 0x6c, /* 01101100 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x36, /* 00110110 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 253 0xfd '�' */ + 0x78, /* 01111000 */ + 0x0c, /* 00001100 */ + 0x18, /* 00011000 */ + 0x30, /* 00110000 */ + 0x7c, /* 01111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 254 0xfe '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x3c, /* 00111100 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + + /* 255 0xff '�' */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + 0x00, /* 00000000 */ + +}; diff --git a/kernel/graphics/fonts/font_sun_12x22.h b/kernel/graphics/fonts/font_sun_12x22.h new file mode 100644 index 0000000..5697a3e --- /dev/null +++ b/kernel/graphics/fonts/font_sun_12x22.h @@ -0,0 +1,6204 @@ + +#define FONTDATAMAX_SUN_12x22 11264 + +unsigned char fontdata_sun_12x22[FONTDATAMAX_SUN_12x22] = { + /* 0 0x00 '^@' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 1 0x01 '^A' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 2 0x02 '^B' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 3 0x03 '^C' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 4 0x04 '^D' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 5 0x05 '^E' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 6 0x06 '^F' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 7 0x07 '^G' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 8 0x08 '^H' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 9 0x09 '^I' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 10 0x0a '^J' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 11 0x0b '^K' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 12 0x0c '^L' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 13 0x0d '^M' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 14 0x0e '^N' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 15 0x0f '^O' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 16 0x10 '^P' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 17 0x11 '^Q' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 18 0x12 '^R' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 19 0x13 '^S' */ + 0x00, 0x00, /* 000000000000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 20 0x14 '^T' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0xf0, /* 000111111111 */ + 0x3c, 0xc0, /* 001111001100 */ + 0x7c, 0xc0, /* 011111001100 */ + 0x7c, 0xc0, /* 011111001100 */ + 0x7c, 0xc0, /* 011111001100 */ + 0x3c, 0xc0, /* 001111001100 */ + 0x1c, 0xc0, /* 000111001100 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x1c, 0xe0, /* 000111001110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 21 0x15 '^U' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x01, 0x80, /* 000000011000 */ + 0x01, 0x80, /* 000000011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 22 0x16 '^V' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 23 0x17 '^W' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 24 0x18 '^X' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 25 0x19 '^Y' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 26 0x1a '^Z' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 27 0x1b '^[' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 28 0x1c '^\' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 29 0x1d '^]' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 30 0x1e '^^' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 31 0x1f '^_' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 32 0x20 ' ' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 33 0x21 '!' */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 34 0x22 '"' */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 35 0x23 '#' */ + 0x00, 0x00, /* 000000000000 */ + 0x03, 0x30, /* 000000110011 */ + 0x03, 0x30, /* 000000110011 */ + 0x03, 0x30, /* 000000110011 */ + 0x06, 0x60, /* 000001100110 */ + 0x1f, 0xf0, /* 000111111111 */ + 0x1f, 0xf0, /* 000111111111 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x7f, 0xc0, /* 011111111100 */ + 0x7f, 0xc0, /* 011111111100 */ + 0x33, 0x00, /* 001100110000 */ + 0x66, 0x00, /* 011001100000 */ + 0x66, 0x00, /* 011001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 36 0x24 '$' */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x66, 0xe0, /* 011001101110 */ + 0x66, 0x60, /* 011001100110 */ + 0x66, 0x00, /* 011001100000 */ + 0x3e, 0x00, /* 001111100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x07, 0xc0, /* 000001111100 */ + 0x06, 0x60, /* 000001100110 */ + 0x06, 0x60, /* 000001100110 */ + 0x66, 0x60, /* 011001100110 */ + 0x7f, 0xc0, /* 011111111100 */ + 0x3f, 0x80, /* 001111111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 37 0x25 '%' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x38, 0xc0, /* 001110001100 */ + 0x4c, 0xc0, /* 010011001100 */ + 0x45, 0x80, /* 010001011000 */ + 0x65, 0x80, /* 011001011000 */ + 0x3b, 0x00, /* 001110110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0d, 0xc0, /* 000011011100 */ + 0x1a, 0x60, /* 000110100110 */ + 0x1a, 0x20, /* 000110100010 */ + 0x33, 0x20, /* 001100110010 */ + 0x31, 0xc0, /* 001100011100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 38 0x26 '&' */ + 0x00, 0x00, /* 000000000000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x18, 0xc0, /* 000110001100 */ + 0x18, 0xc0, /* 000110001100 */ + 0x0f, 0x80, /* 000011111000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x3e, 0x00, /* 001111100000 */ + 0x77, 0x00, /* 011101110000 */ + 0x63, 0x60, /* 011000110110 */ + 0x61, 0xe0, /* 011000011110 */ + 0x61, 0xc0, /* 011000011100 */ + 0x61, 0x80, /* 011000011000 */ + 0x3f, 0xe0, /* 001111111110 */ + 0x1e, 0x60, /* 000111100110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 39 0x27 ''' */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 40 0x28 '(' */ + 0x00, 0x00, /* 000000000000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x01, 0x80, /* 000000011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 41 0x29 ')' */ + 0x00, 0x00, /* 000000000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 42 0x2a '*' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x66, 0x60, /* 011001100110 */ + 0x76, 0xe0, /* 011101101110 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x76, 0xe0, /* 011101101110 */ + 0x66, 0x60, /* 011001100110 */ + 0x06, 0x00, /* 000001100000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 43 0x2b '+' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 44 0x2c ',' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 45 0x2d '-' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 46 0x2e '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 47 0x2f '/' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x01, 0x80, /* 000000011000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 48 0x30 '0' */ + 0x00, 0x00, /* 000000000000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x11, 0x80, /* 000100011000 */ + 0x10, 0xc0, /* 000100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0x80, /* 001100001000 */ + 0x18, 0x80, /* 000110001000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 49 0x31 '1' */ + 0x00, 0x00, /* 000000000000 */ + 0x02, 0x00, /* 000000100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x36, 0x00, /* 001101100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 50 0x32 '2' */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x3f, 0x80, /* 001111111000 */ + 0x61, 0xc0, /* 011000011100 */ + 0x40, 0xc0, /* 010000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x30, 0x20, /* 001100000010 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 51 0x33 '3' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x1f, 0xc0, /* 000111111100 */ + 0x20, 0xe0, /* 001000001110 */ + 0x40, 0x60, /* 010000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0xe0, /* 000000001110 */ + 0x07, 0xc0, /* 000001111100 */ + 0x0f, 0xc0, /* 000011111100 */ + 0x00, 0xe0, /* 000000001110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x40, 0x60, /* 010000000110 */ + 0x60, 0x40, /* 011000000100 */ + 0x3f, 0x80, /* 001111111000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 52 0x34 '4' */ + 0x00, 0x00, /* 000000000000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x80, /* 000000111000 */ + 0x03, 0x80, /* 000000111000 */ + 0x05, 0x80, /* 000001011000 */ + 0x05, 0x80, /* 000001011000 */ + 0x09, 0x80, /* 000010011000 */ + 0x09, 0x80, /* 000010011000 */ + 0x11, 0x80, /* 000100011000 */ + 0x11, 0x80, /* 000100011000 */ + 0x21, 0x80, /* 001000011000 */ + 0x3f, 0xe0, /* 001111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x01, 0x80, /* 000000011000 */ + 0x01, 0x80, /* 000000011000 */ + 0x01, 0x80, /* 000000011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 53 0x35 '5' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0xc0, /* 000011111100 */ + 0x0f, 0xc0, /* 000011111100 */ + 0x10, 0x00, /* 000100000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x20, 0x00, /* 001000000000 */ + 0x3f, 0x80, /* 001111111000 */ + 0x31, 0xc0, /* 001100011100 */ + 0x00, 0xe0, /* 000000001110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x40, 0x60, /* 010000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x30, 0xc0, /* 001100001100 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 54 0x36 '6' */ + 0x00, 0x00, /* 000000000000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x67, 0x80, /* 011001111000 */ + 0x6f, 0xc0, /* 011011111100 */ + 0x70, 0xe0, /* 011100001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0x40, /* 011100000100 */ + 0x3f, 0x80, /* 001111111000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 55 0x37 '7' */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0xe0, /* 000111111110 */ + 0x3f, 0xe0, /* 001111111110 */ + 0x60, 0x40, /* 011000000100 */ + 0x00, 0x40, /* 000000000100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0x80, /* 000000001000 */ + 0x00, 0x80, /* 000000001000 */ + 0x01, 0x80, /* 000000011000 */ + 0x01, 0x00, /* 000000010000 */ + 0x01, 0x00, /* 000000010000 */ + 0x03, 0x00, /* 000000110000 */ + 0x02, 0x00, /* 000000100000 */ + 0x02, 0x00, /* 000000100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x04, 0x00, /* 000001000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 56 0x38 '8' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x11, 0x80, /* 000100011000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x18, 0x80, /* 000110001000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x11, 0x80, /* 000100011000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x18, 0x80, /* 000110001000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 57 0x39 '9' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xe0, /* 001000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0xe0, /* 011100001110 */ + 0x3f, 0x60, /* 001111110110 */ + 0x1e, 0x60, /* 000111100110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x01, 0x80, /* 000000011000 */ + 0x07, 0x00, /* 000001110000 */ + 0x3c, 0x00, /* 001111000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 58 0x3a ':' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 59 0x3b ';' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 60 0x3c '<' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x60, /* 000000000110 */ + 0x01, 0xc0, /* 000000011100 */ + 0x07, 0x00, /* 000001110000 */ + 0x1c, 0x00, /* 000111000000 */ + 0x70, 0x00, /* 011100000000 */ + 0x70, 0x00, /* 011100000000 */ + 0x1c, 0x00, /* 000111000000 */ + 0x07, 0x00, /* 000001110000 */ + 0x01, 0xc0, /* 000000011100 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 61 0x3d '=' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 62 0x3e '>' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x38, 0x00, /* 001110000000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x03, 0x80, /* 000000111000 */ + 0x00, 0xe0, /* 000000001110 */ + 0x00, 0xe0, /* 000000001110 */ + 0x03, 0x80, /* 000000111000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x38, 0x00, /* 001110000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 63 0x3f '?' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x39, 0xc0, /* 001110011100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 64 0x40 '@' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x30, 0x60, /* 001100000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x67, 0x20, /* 011001110010 */ + 0x6f, 0xa0, /* 011011111010 */ + 0x6c, 0xa0, /* 011011001010 */ + 0x6c, 0xa0, /* 011011001010 */ + 0x67, 0xe0, /* 011001111110 */ + 0x60, 0x00, /* 011000000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x3f, 0xe0, /* 001111111110 */ + 0x0f, 0xe0, /* 000011111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 65 0x41 'A' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x09, 0x00, /* 000010010000 */ + 0x11, 0x80, /* 000100011000 */ + 0x11, 0x80, /* 000100011000 */ + 0x10, 0x80, /* 000100001000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x20, 0x40, /* 001000000100 */ + 0x40, 0x60, /* 010000000110 */ + 0x40, 0x60, /* 010000000110 */ + 0xe0, 0xf0, /* 111000001111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 66 0x42 'B' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0x00, /* 111111110000 */ + 0x60, 0x80, /* 011000001000 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0xc0, /* 011000001100 */ + 0x61, 0x80, /* 011000011000 */ + 0x7f, 0x80, /* 011111111000 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0xc0, /* 011000001100 */ + 0xff, 0x80, /* 111111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 67 0x43 'C' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0xc0, /* 000011111100 */ + 0x10, 0x60, /* 000100000110 */ + 0x20, 0x20, /* 001000000010 */ + 0x20, 0x00, /* 001000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x20, 0x00, /* 001000000000 */ + 0x30, 0x20, /* 001100000010 */ + 0x18, 0x40, /* 000110000100 */ + 0x0f, 0x80, /* 000011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 68 0x44 'D' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0x00, /* 111111110000 */ + 0x61, 0xc0, /* 011000011100 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x40, /* 011000000100 */ + 0x61, 0x80, /* 011000011000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 69 0x45 'E' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xc0, /* 011111111100 */ + 0x30, 0x40, /* 001100000100 */ + 0x30, 0x40, /* 001100000100 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x80, /* 001100001000 */ + 0x3f, 0x80, /* 001111111000 */ + 0x30, 0x80, /* 001100001000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x20, /* 001100000010 */ + 0x30, 0x20, /* 001100000010 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 70 0x46 'F' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xc0, /* 011111111100 */ + 0x30, 0x40, /* 001100000100 */ + 0x30, 0x40, /* 001100000100 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x80, /* 001100001000 */ + 0x3f, 0x80, /* 001111111000 */ + 0x30, 0x80, /* 001100001000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 71 0x47 'G' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0xc0, /* 000011111100 */ + 0x10, 0x60, /* 000100000110 */ + 0x20, 0x20, /* 001000000010 */ + 0x20, 0x00, /* 001000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x61, 0xf0, /* 011000011111 */ + 0x60, 0x60, /* 011000000110 */ + 0x20, 0x60, /* 001000000110 */ + 0x30, 0x60, /* 001100000110 */ + 0x18, 0x60, /* 000110000110 */ + 0x0f, 0x80, /* 000011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 72 0x48 'H' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf0, 0xf0, /* 111100001111 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0xf0, 0xf0, /* 111100001111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 73 0x49 'I' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 74 0x4a 'J' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x04, 0x00, /* 000001000000 */ + 0x38, 0x00, /* 001110000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 75 0x4b 'K' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf0, 0xe0, /* 111100001110 */ + 0x61, 0x80, /* 011000011000 */ + 0x63, 0x00, /* 011000110000 */ + 0x66, 0x00, /* 011001100000 */ + 0x6c, 0x00, /* 011011000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x7c, 0x00, /* 011111000000 */ + 0x6e, 0x00, /* 011011100000 */ + 0x67, 0x00, /* 011001110000 */ + 0x63, 0x80, /* 011000111000 */ + 0x61, 0xc0, /* 011000011100 */ + 0x60, 0xe0, /* 011000001110 */ + 0xf0, 0x70, /* 111100000111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 76 0x4c 'L' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x20, /* 001100000010 */ + 0x30, 0x20, /* 001100000010 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 77 0x4d 'M' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xe0, 0x70, /* 111000000111 */ + 0x60, 0xe0, /* 011000001110 */ + 0x70, 0xe0, /* 011100001110 */ + 0x70, 0xe0, /* 011100001110 */ + 0x70, 0xe0, /* 011100001110 */ + 0x59, 0x60, /* 010110010110 */ + 0x59, 0x60, /* 010110010110 */ + 0x59, 0x60, /* 010110010110 */ + 0x4d, 0x60, /* 010011010110 */ + 0x4e, 0x60, /* 010011100110 */ + 0x4e, 0x60, /* 010011100110 */ + 0x44, 0x60, /* 010001000110 */ + 0x44, 0x60, /* 010001000110 */ + 0xe4, 0xf0, /* 111001001111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 78 0x4e 'N' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xc0, 0x70, /* 110000000111 */ + 0x60, 0x20, /* 011000000010 */ + 0x70, 0x20, /* 011100000010 */ + 0x78, 0x20, /* 011110000010 */ + 0x58, 0x20, /* 010110000010 */ + 0x4c, 0x20, /* 010011000010 */ + 0x46, 0x20, /* 010001100010 */ + 0x47, 0x20, /* 010001110010 */ + 0x43, 0x20, /* 010000110010 */ + 0x41, 0xa0, /* 010000011010 */ + 0x40, 0xe0, /* 010000001110 */ + 0x40, 0xe0, /* 010000001110 */ + 0x40, 0x60, /* 010000000110 */ + 0xe0, 0x30, /* 111000000011 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 79 0x4f 'O' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x20, 0x60, /* 001000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x20, 0x40, /* 001000000100 */ + 0x30, 0x40, /* 001100000100 */ + 0x18, 0x80, /* 000110001000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 80 0x50 'P' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0x80, /* 011111111000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0x60, /* 001100000110 */ + 0x30, 0x60, /* 001100000110 */ + 0x30, 0x60, /* 001100000110 */ + 0x30, 0xc0, /* 001100001100 */ + 0x37, 0x80, /* 001101111000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 81 0x51 'Q' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x20, 0x60, /* 001000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x30, 0x40, /* 001100000100 */ + 0x38, 0x40, /* 001110000100 */ + 0x1f, 0x80, /* 000111111000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x23, 0x90, /* 001000111001 */ + 0x01, 0xe0, /* 000000011110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 82 0x52 'R' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0x00, /* 111111110000 */ + 0x61, 0x80, /* 011000011000 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0x80, /* 011000001000 */ + 0x7f, 0x00, /* 011111110000 */ + 0x7c, 0x00, /* 011111000000 */ + 0x6e, 0x00, /* 011011100000 */ + 0x67, 0x00, /* 011001110000 */ + 0x63, 0x80, /* 011000111000 */ + 0x61, 0xc0, /* 011000011100 */ + 0x60, 0xe0, /* 011000001110 */ + 0xf0, 0x70, /* 111100000111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 83 0x53 'S' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0xe0, /* 000111111110 */ + 0x30, 0x60, /* 001100000110 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x70, 0x00, /* 011100000000 */ + 0x3c, 0x00, /* 001111000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x07, 0x80, /* 000001111000 */ + 0x01, 0xc0, /* 000000011100 */ + 0x00, 0xe0, /* 000000001110 */ + 0x40, 0x60, /* 010000000110 */ + 0x40, 0x60, /* 010000000110 */ + 0x60, 0xc0, /* 011000001100 */ + 0x7f, 0x80, /* 011111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 84 0x54 'T' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x46, 0x20, /* 010001100010 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 85 0x55 'U' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf0, 0x70, /* 111100000111 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x70, 0x40, /* 011100000100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 86 0x56 'V' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xe0, 0xe0, /* 111000001110 */ + 0x60, 0x40, /* 011000000100 */ + 0x30, 0x80, /* 001100001000 */ + 0x30, 0x80, /* 001100001000 */ + 0x30, 0x80, /* 001100001000 */ + 0x19, 0x00, /* 000110010000 */ + 0x19, 0x00, /* 000110010000 */ + 0x19, 0x00, /* 000110010000 */ + 0x0a, 0x00, /* 000010100000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x04, 0x00, /* 000001000000 */ + 0x04, 0x00, /* 000001000000 */ + 0x04, 0x00, /* 000001000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 87 0x57 'W' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xfe, 0xf0, /* 111111101111 */ + 0x66, 0x20, /* 011001100010 */ + 0x66, 0x20, /* 011001100010 */ + 0x66, 0x20, /* 011001100010 */ + 0x76, 0x20, /* 011101100010 */ + 0x77, 0x40, /* 011101110100 */ + 0x33, 0x40, /* 001100110100 */ + 0x37, 0x40, /* 001101110100 */ + 0x3b, 0xc0, /* 001110111100 */ + 0x3b, 0x80, /* 001110111000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 88 0x58 'X' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf0, 0x70, /* 111100000111 */ + 0x60, 0x20, /* 011000000010 */ + 0x30, 0x40, /* 001100000100 */ + 0x38, 0x80, /* 001110001000 */ + 0x18, 0x80, /* 000110001000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x11, 0x80, /* 000100011000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x40, 0x60, /* 010000000110 */ + 0xe0, 0xf0, /* 111000001111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 89 0x59 'Y' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf0, 0x70, /* 111100000111 */ + 0x60, 0x20, /* 011000000010 */ + 0x30, 0x40, /* 001100000100 */ + 0x18, 0x80, /* 000110001000 */ + 0x18, 0x80, /* 000110001000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 90 0x5a 'Z' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xe0, /* 001111111110 */ + 0x20, 0xc0, /* 001000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x01, 0x80, /* 000000011000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x18, 0x20, /* 000110000010 */ + 0x3f, 0xe0, /* 001111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 91 0x5b '[' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 92 0x5c '\' */ + 0x00, 0x00, /* 000000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x01, 0x80, /* 000000011000 */ + 0x01, 0x80, /* 000000011000 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 93 0x5d ']' */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 94 0x5e '^' */ + 0x00, 0x00, /* 000000000000 */ + 0x04, 0x00, /* 000001000000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x1b, 0x00, /* 000110110000 */ + 0x31, 0x80, /* 001100011000 */ + 0x60, 0xc0, /* 011000001100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 95 0x5f '_' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 96 0x60 '`' */ + 0x00, 0x00, /* 000000000000 */ + 0x01, 0x00, /* 000000010000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x07, 0x80, /* 000001111000 */ + 0x07, 0x80, /* 000001111000 */ + 0x03, 0x00, /* 000000110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 97 0x61 'a' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x10, 0xc0, /* 000100001100 */ + 0x03, 0xc0, /* 000000111100 */ + 0x1c, 0xc0, /* 000111001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0xe0, /* 000111101110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 98 0x62 'b' */ + 0x00, 0x00, /* 000000000000 */ + 0x20, 0x00, /* 001000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0xe0, 0x00, /* 111000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x67, 0x80, /* 011001111000 */ + 0x6f, 0xc0, /* 011011111100 */ + 0x70, 0xe0, /* 011100001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0x60, /* 011100000110 */ + 0x78, 0xc0, /* 011110001100 */ + 0x4f, 0x80, /* 010011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 99 0x63 'c' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x31, 0xc0, /* 001100011100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x70, 0x40, /* 011100000100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 100 0x64 'd' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0xe0, /* 000000001110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x0f, 0x60, /* 000011110110 */ + 0x31, 0xe0, /* 001100011110 */ + 0x20, 0xe0, /* 001000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0xe0, /* 011100001110 */ + 0x39, 0x60, /* 001110010110 */ + 0x1e, 0x70, /* 000111100111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 101 0x65 'e' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x18, 0x60, /* 000110000110 */ + 0x0f, 0x80, /* 000011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 102 0x66 'f' */ + 0x00, 0x00, /* 000000000000 */ + 0x03, 0x80, /* 000000111000 */ + 0x04, 0xc0, /* 000001001100 */ + 0x04, 0xc0, /* 000001001100 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x3f, 0x80, /* 001111111000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 103 0x67 'g' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x20, /* 000111110010 */ + 0x31, 0xe0, /* 001100011110 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0xc0, /* 011000001100 */ + 0x60, 0xc0, /* 011000001100 */ + 0x31, 0x80, /* 001100011000 */ + 0x3f, 0x00, /* 001111110000 */ + 0x60, 0x00, /* 011000000000 */ + 0x7f, 0xc0, /* 011111111100 */ + 0x3f, 0xe0, /* 001111111110 */ + 0x20, 0x60, /* 001000000110 */ + 0x40, 0x20, /* 010000000010 */ + 0x40, 0x20, /* 010000000010 */ + 0x7f, 0xc0, /* 011111111100 */ + 0x3f, 0x80, /* 001111111000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 104 0x68 'h' */ + 0x00, 0x00, /* 000000000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x70, 0x00, /* 011100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x37, 0x80, /* 001101111000 */ + 0x39, 0xc0, /* 001110011100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x79, 0xe0, /* 011110011110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 105 0x69 'i' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 106 0x6a 'j' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x03, 0xc0, /* 000000111100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x38, 0x80, /* 001110001000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 107 0x6b 'k' */ + 0x00, 0x00, /* 000000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0xe0, 0x00, /* 111000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x61, 0xc0, /* 011000011100 */ + 0x63, 0x00, /* 011000110000 */ + 0x66, 0x00, /* 011001100000 */ + 0x7c, 0x00, /* 011111000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x7c, 0x00, /* 011111000000 */ + 0x6e, 0x00, /* 011011100000 */ + 0x67, 0x00, /* 011001110000 */ + 0x63, 0x80, /* 011000111000 */ + 0xf1, 0xe0, /* 111100011110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 108 0x6c 'l' */ + 0x00, 0x00, /* 000000000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 109 0x6d 'm' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xdd, 0xc0, /* 110111011100 */ + 0x6e, 0xe0, /* 011011101110 */ + 0x66, 0x60, /* 011001100110 */ + 0x66, 0x60, /* 011001100110 */ + 0x66, 0x60, /* 011001100110 */ + 0x66, 0x60, /* 011001100110 */ + 0x66, 0x60, /* 011001100110 */ + 0x66, 0x60, /* 011001100110 */ + 0x66, 0x60, /* 011001100110 */ + 0xef, 0x70, /* 111011110111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 110 0x6e 'n' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x27, 0x80, /* 001001111000 */ + 0x79, 0xc0, /* 011110011100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x79, 0xe0, /* 011110011110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 111 0x6f 'o' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xe0, /* 001000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0x40, /* 011100000100 */ + 0x38, 0x80, /* 001110001000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 112 0x70 'p' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xef, 0x80, /* 111011111000 */ + 0x71, 0xc0, /* 011100011100 */ + 0x60, 0xe0, /* 011000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x40, /* 011000000100 */ + 0x70, 0x80, /* 011100001000 */ + 0x7f, 0x00, /* 011111110000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0xf0, 0x00, /* 111100000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 113 0x71 'q' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x20, /* 000011110010 */ + 0x11, 0xe0, /* 000100011110 */ + 0x20, 0xe0, /* 001000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0x60, /* 011100000110 */ + 0x38, 0xe0, /* 001110001110 */ + 0x1f, 0xe0, /* 000111111110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0x60, /* 000000000110 */ + 0x00, 0xf0, /* 000000001111 */ + 0x00, 0x00, /* 000000000000 */ + + /* 114 0x72 'r' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x73, 0x80, /* 011100111000 */ + 0x34, 0xc0, /* 001101001100 */ + 0x38, 0xc0, /* 001110001100 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 115 0x73 's' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0xc0, /* 000111111100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0x40, /* 001100000100 */ + 0x38, 0x00, /* 001110000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x07, 0x80, /* 000001111000 */ + 0x01, 0xc0, /* 000000011100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x3f, 0x80, /* 001111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 116 0x74 't' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x04, 0x00, /* 000001000000 */ + 0x04, 0x00, /* 000001000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x7f, 0xc0, /* 011111111100 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0c, 0x20, /* 000011000010 */ + 0x0e, 0x40, /* 000011100100 */ + 0x07, 0x80, /* 000001111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 117 0x75 'u' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x79, 0xe0, /* 011110011110 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0x60, /* 000111100110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 118 0x76 'v' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf0, 0x70, /* 111100000111 */ + 0x60, 0x20, /* 011000000010 */ + 0x30, 0x40, /* 001100000100 */ + 0x30, 0x40, /* 001100000100 */ + 0x18, 0x80, /* 000110001000 */ + 0x18, 0x80, /* 000110001000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 119 0x77 'w' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0x70, /* 111111110111 */ + 0x66, 0x20, /* 011001100010 */ + 0x66, 0x20, /* 011001100010 */ + 0x66, 0x20, /* 011001100010 */ + 0x37, 0x40, /* 001101110100 */ + 0x3b, 0x40, /* 001110110100 */ + 0x3b, 0x40, /* 001110110100 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 120 0x78 'x' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf8, 0xf0, /* 111110001111 */ + 0x70, 0x40, /* 011100000100 */ + 0x38, 0x80, /* 001110001000 */ + 0x1d, 0x00, /* 000111010000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0b, 0x80, /* 000010111000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xe0, /* 001000001110 */ + 0xf1, 0xf0, /* 111100011111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 121 0x79 'y' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf0, 0xf0, /* 111100001111 */ + 0x60, 0x20, /* 011000000010 */ + 0x30, 0x40, /* 001100000100 */ + 0x30, 0x40, /* 001100000100 */ + 0x18, 0x80, /* 000110001000 */ + 0x18, 0x80, /* 000110001000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x04, 0x00, /* 000001000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x08, 0x00, /* 000010000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x70, 0x00, /* 011100000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 122 0x7a 'z' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x60, 0xe0, /* 011000001110 */ + 0x41, 0xc0, /* 010000011100 */ + 0x03, 0x80, /* 000000111000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x1c, 0x00, /* 000111000000 */ + 0x38, 0x20, /* 001110000010 */ + 0x70, 0x60, /* 011100000110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 123 0x7b '{' */ + 0x00, 0x00, /* 000000000000 */ + 0x03, 0x80, /* 000000111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x38, 0x00, /* 001110000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x80, /* 000000111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 124 0x7c '|' */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 125 0x7d '}' */ + 0x00, 0x00, /* 000000000000 */ + 0x1c, 0x00, /* 000111000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x01, 0xc0, /* 000000011100 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1c, 0x00, /* 000111000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 126 0x7e '~' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1c, 0x20, /* 000111000010 */ + 0x3e, 0x60, /* 001111100110 */ + 0x67, 0xc0, /* 011001111100 */ + 0x43, 0x80, /* 010000111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 127 0x7f '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 128 0x80 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0xc0, /* 000011111100 */ + 0x10, 0x60, /* 000100000110 */ + 0x20, 0x20, /* 001000000010 */ + 0x20, 0x00, /* 001000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x20, 0x00, /* 001000000000 */ + 0x30, 0x20, /* 001100000010 */ + 0x18, 0x40, /* 000110000100 */ + 0x0f, 0x80, /* 000011111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x01, 0x80, /* 000000011000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 129 0x81 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x79, 0xe0, /* 011110011110 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0x60, /* 000111100110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 130 0x82 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x18, 0x60, /* 000110000110 */ + 0x0f, 0x80, /* 000011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 131 0x83 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x02, 0x00, /* 000000100000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x10, 0xc0, /* 000100001100 */ + 0x03, 0xc0, /* 000000111100 */ + 0x1c, 0xc0, /* 000111001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0xe0, /* 000111101110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 132 0x84 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x10, 0xc0, /* 000100001100 */ + 0x03, 0xc0, /* 000000111100 */ + 0x1c, 0xc0, /* 000111001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0xe0, /* 000111101110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 133 0x85 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x10, 0xc0, /* 000100001100 */ + 0x03, 0xc0, /* 000000111100 */ + 0x1c, 0xc0, /* 000111001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0xe0, /* 000111101110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 134 0x86 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x07, 0x00, /* 000001110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x10, 0xc0, /* 000100001100 */ + 0x03, 0xc0, /* 000000111100 */ + 0x1c, 0xc0, /* 000111001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0xe0, /* 000111101110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 135 0x87 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x31, 0xc0, /* 001100011100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x70, 0x40, /* 011100000100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x1f, 0x80, /* 000111111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x01, 0x80, /* 000000011000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 136 0x88 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x02, 0x00, /* 000000100000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x18, 0x60, /* 000110000110 */ + 0x0f, 0x80, /* 000011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 137 0x89 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x18, 0x60, /* 000110000110 */ + 0x0f, 0x80, /* 000011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 138 0x8a '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x60, 0x00, /* 011000000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x18, 0x60, /* 000110000110 */ + 0x0f, 0x80, /* 000011111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 139 0x8b '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 140 0x8c '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x04, 0x00, /* 000001000000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x1b, 0x00, /* 000110110000 */ + 0x31, 0x80, /* 001100011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 141 0x8d '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 142 0x8e '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x04, 0x00, /* 000001000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x19, 0x80, /* 000110011000 */ + 0x11, 0x80, /* 000100011000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x40, 0x60, /* 010000000110 */ + 0xe0, 0xf0, /* 111000001111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 143 0x8f '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x19, 0x80, /* 000110011000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x04, 0x00, /* 000001000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x19, 0x80, /* 000110011000 */ + 0x11, 0x80, /* 000100011000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x60, 0x60, /* 011000000110 */ + 0x40, 0x60, /* 010000000110 */ + 0xe0, 0xf0, /* 111000001111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 144 0x90 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x08, 0x00, /* 000010000000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x30, 0x20, /* 001100000010 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x80, /* 001100001000 */ + 0x3f, 0x80, /* 001111111000 */ + 0x30, 0x80, /* 001100001000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x20, /* 001100000010 */ + 0x30, 0x20, /* 001100000010 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 145 0x91 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3d, 0xe0, /* 001111011110 */ + 0x66, 0x30, /* 011001100011 */ + 0x46, 0x30, /* 010001100011 */ + 0x06, 0x30, /* 000001100011 */ + 0x3f, 0xf0, /* 001111111111 */ + 0x66, 0x00, /* 011001100000 */ + 0xc6, 0x00, /* 110001100000 */ + 0xc6, 0x00, /* 110001100000 */ + 0xe7, 0x30, /* 111001110011 */ + 0x7d, 0xe0, /* 011111011110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 146 0x92 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x03, 0xf0, /* 000000111111 */ + 0x07, 0x10, /* 000001110001 */ + 0x07, 0x10, /* 000001110001 */ + 0x0b, 0x00, /* 000010110000 */ + 0x0b, 0x00, /* 000010110000 */ + 0x0b, 0x20, /* 000010110010 */ + 0x13, 0xe0, /* 000100111110 */ + 0x13, 0x20, /* 000100110010 */ + 0x3f, 0x00, /* 001111110000 */ + 0x23, 0x00, /* 001000110000 */ + 0x23, 0x00, /* 001000110000 */ + 0x43, 0x10, /* 010000110001 */ + 0x43, 0x10, /* 010000110001 */ + 0xe7, 0xf0, /* 111001111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 147 0x93 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x02, 0x00, /* 000000100000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xe0, /* 001000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0x40, /* 011100000100 */ + 0x38, 0x80, /* 001110001000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 148 0x94 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xe0, /* 001000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0x40, /* 011100000100 */ + 0x38, 0x80, /* 001110001000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 149 0x95 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x03, 0x00, /* 000000110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xe0, /* 001000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0x40, /* 011100000100 */ + 0x38, 0x80, /* 001110001000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 150 0x96 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x02, 0x00, /* 000000100000 */ + 0x07, 0x00, /* 000001110000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x00, 0x00, /* 000000000000 */ + 0x79, 0xe0, /* 011110011110 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0x60, /* 000111100110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 151 0x97 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x79, 0xe0, /* 011110011110 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0x60, /* 000111100110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 152 0x98 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xf0, 0xf0, /* 111100001111 */ + 0x60, 0x20, /* 011000000010 */ + 0x30, 0x40, /* 001100000100 */ + 0x30, 0x40, /* 001100000100 */ + 0x18, 0x80, /* 000110001000 */ + 0x18, 0x80, /* 000110001000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x0d, 0x00, /* 000011010000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x04, 0x00, /* 000001000000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x08, 0x00, /* 000010000000 */ + 0x78, 0x00, /* 011110000000 */ + 0x70, 0x00, /* 011100000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 153 0x99 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xc0, /* 001000001100 */ + 0x20, 0x60, /* 001000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x20, 0x40, /* 001000000100 */ + 0x30, 0x40, /* 001100000100 */ + 0x18, 0x80, /* 000110001000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 154 0x9a '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0xe0, 0x30, /* 111000000011 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x60, 0x20, /* 011000000010 */ + 0x70, 0x40, /* 011100000100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 155 0x9b '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x36, 0xc0, /* 001101101100 */ + 0x26, 0xc0, /* 001001101100 */ + 0x66, 0x00, /* 011001100000 */ + 0x66, 0x00, /* 011001100000 */ + 0x66, 0x00, /* 011001100000 */ + 0x66, 0x00, /* 011001100000 */ + 0x76, 0x40, /* 011101100100 */ + 0x36, 0xc0, /* 001101101100 */ + 0x1f, 0x80, /* 000111111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 156 0x9c '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x1c, 0xc0, /* 000111001100 */ + 0x18, 0xc0, /* 000110001100 */ + 0x18, 0x00, /* 000110000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x7e, 0x00, /* 011111100000 */ + 0x7e, 0x00, /* 011111100000 */ + 0x18, 0x00, /* 000110000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x3e, 0x20, /* 001111100010 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x61, 0xc0, /* 011000011100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 157 0x9d '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x30, 0xc0, /* 001100001100 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 158 0x9e '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 159 0x9f '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 160 0xa0 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x18, 0xc0, /* 000110001100 */ + 0x10, 0xc0, /* 000100001100 */ + 0x03, 0xc0, /* 000000111100 */ + 0x1c, 0xc0, /* 000111001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0xe0, /* 000111101110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 161 0xa1 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1e, 0x00, /* 000111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 162 0xa2 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x80, /* 000011111000 */ + 0x11, 0xc0, /* 000100011100 */ + 0x20, 0xe0, /* 001000001110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x60, 0x60, /* 011000000110 */ + 0x70, 0x40, /* 011100000100 */ + 0x38, 0x80, /* 001110001000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 163 0xa3 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x01, 0x80, /* 000000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x79, 0xe0, /* 011110011110 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1e, 0x60, /* 000111100110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 164 0xa4 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x1c, 0x40, /* 000111000100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x23, 0x80, /* 001000111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x27, 0x80, /* 001001111000 */ + 0x79, 0xc0, /* 011110011100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x79, 0xe0, /* 011110011110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 165 0xa5 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x1c, 0x40, /* 000111000100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x23, 0x80, /* 001000111000 */ + 0xc0, 0x70, /* 110000000111 */ + 0x60, 0x20, /* 011000000010 */ + 0x70, 0x20, /* 011100000010 */ + 0x78, 0x20, /* 011110000010 */ + 0x5c, 0x20, /* 010111000010 */ + 0x4e, 0x20, /* 010011100010 */ + 0x47, 0x20, /* 010001110010 */ + 0x43, 0xa0, /* 010000111010 */ + 0x41, 0xe0, /* 010000011110 */ + 0x40, 0xe0, /* 010000001110 */ + 0x40, 0x60, /* 010000000110 */ + 0xe0, 0x30, /* 111000000011 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 166 0xa6 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x1f, 0x00, /* 000111110000 */ + 0x31, 0x80, /* 001100011000 */ + 0x01, 0x80, /* 000000011000 */ + 0x07, 0x80, /* 000001111000 */ + 0x19, 0x80, /* 000110011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x31, 0x80, /* 001100011000 */ + 0x33, 0x80, /* 001100111000 */ + 0x1d, 0xc0, /* 000111011100 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 167 0xa7 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x07, 0x00, /* 000001110000 */ + 0x19, 0x80, /* 000110011000 */ + 0x10, 0xc0, /* 000100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0x80, /* 001100001000 */ + 0x19, 0x80, /* 000110011000 */ + 0x0e, 0x00, /* 000011100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 168 0xa8 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x03, 0x00, /* 000000110000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x00, /* 000110000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x40, /* 001100000100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x1f, 0x80, /* 000111111000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 169 0xa9 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 170 0xaa '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0xc0, /* 000000001100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 171 0xab '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x10, 0x40, /* 000100000100 */ + 0x10, 0x80, /* 000100001000 */ + 0x11, 0x00, /* 000100010000 */ + 0x3a, 0x00, /* 001110100000 */ + 0x05, 0xc0, /* 000001011100 */ + 0x0a, 0x20, /* 000010100010 */ + 0x10, 0x20, /* 000100000010 */ + 0x20, 0xc0, /* 001000001100 */ + 0x41, 0x00, /* 010000010000 */ + 0x02, 0x00, /* 000000100000 */ + 0x03, 0xe0, /* 000000111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 172 0xac '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x10, 0x00, /* 000100000000 */ + 0x10, 0x40, /* 000100000100 */ + 0x10, 0x80, /* 000100001000 */ + 0x11, 0x00, /* 000100010000 */ + 0x3a, 0x40, /* 001110100100 */ + 0x04, 0xc0, /* 000001001100 */ + 0x09, 0x40, /* 000010010100 */ + 0x12, 0x40, /* 000100100100 */ + 0x24, 0x40, /* 001001000100 */ + 0x47, 0xe0, /* 010001111110 */ + 0x00, 0x40, /* 000000000100 */ + 0x00, 0x40, /* 000000000100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 173 0xad '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 174 0xae '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x60, /* 000001100110 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x19, 0x80, /* 000110011000 */ + 0x33, 0x00, /* 001100110000 */ + 0x66, 0x00, /* 011001100000 */ + 0x33, 0x00, /* 001100110000 */ + 0x19, 0x80, /* 000110011000 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x06, 0x60, /* 000001100110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 175 0xaf '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x66, 0x00, /* 011001100000 */ + 0x33, 0x00, /* 001100110000 */ + 0x19, 0x80, /* 000110011000 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x06, 0x60, /* 000001100110 */ + 0x0c, 0xc0, /* 000011001100 */ + 0x19, 0x80, /* 000110011000 */ + 0x33, 0x00, /* 001100110000 */ + 0x66, 0x00, /* 011001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 176 0xb0 '.' */ + 0x0c, 0x30, /* 000011000011 */ + 0x08, 0x20, /* 000010000010 */ + 0x61, 0x80, /* 011000011000 */ + 0x20, 0x80, /* 001000001000 */ + 0x0c, 0x30, /* 000011000011 */ + 0x08, 0x20, /* 000010000010 */ + 0x61, 0x80, /* 011000011000 */ + 0x20, 0x80, /* 001000001000 */ + 0x0c, 0x30, /* 000011000011 */ + 0x08, 0x20, /* 000010000010 */ + 0x61, 0x80, /* 011000011000 */ + 0x20, 0x80, /* 001000001000 */ + 0x0c, 0x30, /* 000011000011 */ + 0x08, 0x20, /* 000010000010 */ + 0x61, 0x80, /* 011000011000 */ + 0x20, 0x80, /* 001000001000 */ + 0x0c, 0x30, /* 000011000011 */ + 0x08, 0x20, /* 000010000010 */ + 0x61, 0x80, /* 011000011000 */ + 0x20, 0x80, /* 001000001000 */ + 0x0c, 0x30, /* 000011000011 */ + 0x08, 0x20, /* 000010000010 */ + + /* 177 0xb1 '.' */ + 0x77, 0x70, /* 011101110111 */ + 0x22, 0x20, /* 001000100010 */ + 0x88, 0x80, /* 100010001000 */ + 0xdd, 0xd0, /* 110111011101 */ + 0x88, 0x80, /* 100010001000 */ + 0x22, 0x20, /* 001000100010 */ + 0x77, 0x70, /* 011101110111 */ + 0x22, 0x20, /* 001000100010 */ + 0x88, 0x80, /* 100010001000 */ + 0xdd, 0xd0, /* 110111011101 */ + 0x88, 0x80, /* 100010001000 */ + 0x22, 0x20, /* 001000100010 */ + 0x77, 0x70, /* 011101110111 */ + 0x22, 0x20, /* 001000100010 */ + 0x88, 0x80, /* 100010001000 */ + 0xdd, 0xd0, /* 110111011101 */ + 0x88, 0x80, /* 100010001000 */ + 0x22, 0x20, /* 001000100010 */ + 0x77, 0x70, /* 011101110111 */ + 0x22, 0x20, /* 001000100010 */ + 0x88, 0x80, /* 100010001000 */ + 0xdd, 0xd0, /* 110111011101 */ + + /* 178 0xb2 '.' */ + 0xf3, 0xc0, /* 111100111100 */ + 0xf7, 0xd0, /* 111101111101 */ + 0x9e, 0x70, /* 100111100111 */ + 0xdf, 0x70, /* 110111110111 */ + 0xf3, 0xc0, /* 111100111100 */ + 0xf7, 0xd0, /* 111101111101 */ + 0x9e, 0x70, /* 100111100111 */ + 0xdf, 0x70, /* 110111110111 */ + 0xf3, 0xc0, /* 111100111100 */ + 0xf7, 0xd0, /* 111101111101 */ + 0x9e, 0x70, /* 100111100111 */ + 0xdf, 0x70, /* 110111110111 */ + 0xf3, 0xc0, /* 111100111100 */ + 0xf7, 0xd0, /* 111101111101 */ + 0x9e, 0x70, /* 100111100111 */ + 0xdf, 0x70, /* 110111110111 */ + 0xf3, 0xc0, /* 111100111100 */ + 0xf7, 0xd0, /* 111101111101 */ + 0x9e, 0x70, /* 100111100111 */ + 0xdf, 0x70, /* 110111110111 */ + 0xf3, 0xc0, /* 111100111100 */ + 0xf7, 0xd0, /* 111101111101 */ + + /* 179 0xb3 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 180 0xb4 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 181 0xb5 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 182 0xb6 '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 183 0xb7 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0x80, /* 111111111000 */ + 0xff, 0x80, /* 111111111000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 184 0xb8 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 185 0xb9 '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0x01, 0x80, /* 000000011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 186 0xba '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 187 0xbb '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0x80, /* 111111111000 */ + 0xff, 0x80, /* 111111111000 */ + 0x01, 0x80, /* 000000011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 188 0xbc '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0xfd, 0x80, /* 111111011000 */ + 0x01, 0x80, /* 000000011000 */ + 0xff, 0x80, /* 111111111000 */ + 0xff, 0x80, /* 111111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 189 0xbd '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0xff, 0x80, /* 111111111000 */ + 0xff, 0x80, /* 111111111000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 190 0xbe '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 191 0xbf '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 192 0xc0 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 193 0xc1 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 194 0xc2 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 195 0xc3 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 196 0xc4 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 197 0xc5 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 198 0xc6 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 199 0xc7 '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 200 0xc8 '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0f, 0xf0, /* 000011111111 */ + 0x0f, 0xf0, /* 000011111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 201 0xc9 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0xf0, /* 000011111111 */ + 0x0f, 0xf0, /* 000011111111 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 202 0xca '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0xfd, 0xf0, /* 111111011111 */ + 0xfd, 0xf0, /* 111111011111 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 203 0xcb '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0xfd, 0xf0, /* 111111011111 */ + 0xfd, 0xf0, /* 111111011111 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 204 0xcc '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0c, 0x00, /* 000011000000 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0d, 0xf0, /* 000011011111 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 205 0xcd '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 206 0xce '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0xfd, 0xf0, /* 111111011111 */ + 0xfd, 0xf0, /* 111111011111 */ + 0x00, 0x00, /* 000000000000 */ + 0xfd, 0xf0, /* 111111011111 */ + 0xfd, 0xf0, /* 111111011111 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 207 0xcf '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 208 0xd0 '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 209 0xd1 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 210 0xd2 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 211 0xd3 '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0f, 0xf0, /* 000011111111 */ + 0x0f, 0xf0, /* 000011111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 212 0xd4 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 213 0xd5 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 214 0xd6 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0xf0, /* 000011111111 */ + 0x0f, 0xf0, /* 000011111111 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 215 0xd7 '.' */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + 0x0d, 0x80, /* 000011011000 */ + + /* 216 0xd8 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x06, 0x00, /* 000001100000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 217 0xd9 '.' */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0xfe, 0x00, /* 111111100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 218 0xda '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x07, 0xf0, /* 000001111111 */ + 0x07, 0xf0, /* 000001111111 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + + /* 219 0xdb '.' */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + + /* 220 0xdc '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + + /* 221 0xdd '.' */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + 0xfc, 0x00, /* 111111000000 */ + + /* 222 0xde '.' */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + 0x03, 0xf0, /* 000000111111 */ + + /* 223 0xdf '.' */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0xff, 0xf0, /* 111111111111 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 224 0xe0 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 225 0xe1 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x19, 0x80, /* 000110011000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x31, 0x80, /* 001100011000 */ + 0x37, 0x80, /* 001101111000 */ + 0x31, 0x80, /* 001100011000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x31, 0x80, /* 001100011000 */ + 0x77, 0x00, /* 011101110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 226 0xe2 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 227 0xe3 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 228 0xe4 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 229 0xe5 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 230 0xe6 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x30, 0xc0, /* 001100001100 */ + 0x39, 0xc0, /* 001110011100 */ + 0x36, 0xe0, /* 001101101110 */ + 0x30, 0x00, /* 001100000000 */ + 0x30, 0x00, /* 001100000000 */ + 0x60, 0x00, /* 011000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 231 0xe7 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 232 0xe8 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 233 0xe9 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 234 0xea '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 235 0xeb '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 236 0xec '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 237 0xed '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 238 0xee '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 239 0xef '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 240 0xf0 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 241 0xf1 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 242 0xf2 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 243 0xf3 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 244 0xf4 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 245 0xf5 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 246 0xf6 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x7f, 0xe0, /* 011111111110 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 247 0xf7 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 248 0xf8 '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x19, 0x80, /* 000110011000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 249 0xf9 '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 250 0xfa '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 251 0xfb '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 252 0xfc '.' */ + /* FIXME */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 253 0xfd '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x0f, 0x00, /* 000011110000 */ + 0x1f, 0x80, /* 000111111000 */ + 0x31, 0x80, /* 001100011000 */ + 0x21, 0x80, /* 001000011000 */ + 0x03, 0x00, /* 000000110000 */ + 0x06, 0x00, /* 000001100000 */ + 0x0c, 0x00, /* 000011000000 */ + 0x18, 0x40, /* 000110000100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 254 0xfe '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x3f, 0xc0, /* 001111111100 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + + /* 255 0xff '.' */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + 0x00, 0x00, /* 000000000000 */ + +}; diff --git a/kernel/graphics/fonts/font_sun_8x16.h b/kernel/graphics/fonts/font_sun_8x16.h new file mode 100644 index 0000000..1ba1863 --- /dev/null +++ b/kernel/graphics/fonts/font_sun_8x16.h @@ -0,0 +1,517 @@ + +#define FONTDATAMAX_SUN8x16 4096 + +unsigned char fontdata_sun_8x16[FONTDATAMAX_SUN8x16] = { + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0x81, 0xbd, + 0x99, 0x81, 0x81, 0x7e, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x7e, 0xff, 0xdb, 0xff, 0xff, 0xc3, + 0xe7, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, + 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, + 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0xe7, 0xe7, + 0xe7, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, + 0x7e, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, + 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xc3, + 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x42, + 0x42, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd, + 0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, + /* */ 0x00, 0x00, 0x1e, 0x0e, 0x1a, 0x32, 0x78, 0xcc, + 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, + 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x3f, 0x33, 0x3f, 0x30, 0x30, 0x30, + 0x30, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x7f, 0x63, 0x7f, 0x63, 0x63, 0x63, + 0x63, 0x67, 0xe7, 0xe6, 0xc0, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, + 0x3c, 0xdb, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfe, 0xf8, + 0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x02, 0x06, 0x0e, 0x1e, 0x3e, 0xfe, 0x3e, + 0x1e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, + 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, + 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, + 0x6c, 0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, + 0x7e, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0c, 0xfe, + 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, + 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, + 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x66, 0xff, + 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x7c, + 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c, + 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*!*/ 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x18, + 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /*"*/ 0x00, 0x66, 0x66, 0x66, 0x24, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*#*/ 0x00, 0x00, 0x00, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, + 0x6c, 0xfe, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, + /*$*/ 0x18, 0x18, 0x7c, 0xc6, 0xc2, 0xc0, 0x7c, 0x06, + 0x06, 0x86, 0xc6, 0x7c, 0x18, 0x18, 0x00, 0x00, + /*%*/ 0x00, 0x00, 0x00, 0x00, 0xc2, 0xc6, 0x0c, 0x18, + 0x30, 0x60, 0xc6, 0x86, 0x00, 0x00, 0x00, 0x00, + /*&*/ 0x00, 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x76, 0xdc, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /*'*/ 0x00, 0x30, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*(*/ 0x00, 0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, + /*)*/ 0x00, 0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x0c, + 0x0c, 0x0c, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, + /***/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x3c, 0xff, + 0x3c, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*+*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, + 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*,*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, + /*-*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*.*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x0c, 0x18, + 0x30, 0x60, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, + /*0*/ 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xce, 0xde, 0xf6, + 0xe6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*1*/ 0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, + /*2*/ 0x00, 0x00, 0x7c, 0xc6, 0x06, 0x0c, 0x18, 0x30, + 0x60, 0xc0, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, + /*3*/ 0x00, 0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, + 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*4*/ 0x00, 0x00, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc, 0xfe, + 0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x00, 0x00, 0x00, + /*5*/ 0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0x06, + 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*6*/ 0x00, 0x00, 0x38, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*7*/ 0x00, 0x00, 0xfe, 0xc6, 0x06, 0x06, 0x0c, 0x18, + 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, + /*8*/ 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*9*/ 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, + 0x06, 0x06, 0x0c, 0x78, 0x00, 0x00, 0x00, 0x00, + /*:*/ 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, + 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, + /*;*/ 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, + 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, + /*<*/ 0x00, 0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, + 0x30, 0x18, 0x0c, 0x06, 0x00, 0x00, 0x00, 0x00, + /*=*/0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, + 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*>*/ 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x06, + 0x0c, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, + /*?*/ 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x0c, 0x18, 0x18, + 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /*@*/ 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xde, 0xde, + 0xde, 0xdc, 0xc0, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*A*/ 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, + 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, + /*B*/ 0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x66, + 0x66, 0x66, 0x66, 0xfc, 0x00, 0x00, 0x00, 0x00, + /*C*/ 0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xc0, + 0xc0, 0xc2, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, + /*D*/ 0x00, 0x00, 0xf8, 0x6c, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x66, 0x6c, 0xf8, 0x00, 0x00, 0x00, 0x00, + /*E*/ 0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, + 0x60, 0x62, 0x66, 0xfe, 0x00, 0x00, 0x00, 0x00, + /*F*/ 0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, + 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, + /*G*/ 0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xde, + 0xc6, 0xc6, 0x66, 0x3a, 0x00, 0x00, 0x00, 0x00, + /*H*/ 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, + /*I*/ 0x00, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /*J*/ 0x00, 0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, + 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, + /*K*/ 0x00, 0x00, 0xe6, 0x66, 0x66, 0x6c, 0x78, 0x78, + 0x6c, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00, + /*L*/ 0x00, 0x00, 0xf0, 0x60, 0x60, 0x60, 0x60, 0x60, + 0x60, 0x62, 0x66, 0xfe, 0x00, 0x00, 0x00, 0x00, + /*M*/ 0x00, 0x00, 0xc3, 0xe7, 0xff, 0xff, 0xdb, 0xc3, + 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00, + /*N*/ 0x00, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, + 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, + /*O*/ 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*P*/ 0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x60, + 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, + /*Q*/ 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xd6, 0xde, 0x7c, 0x0c, 0x0e, 0x00, 0x00, + /*R*/ 0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x6c, + 0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00, + /*S*/ 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x60, 0x38, 0x0c, + 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*T*/ 0x00, 0x00, 0xff, 0xdb, 0x99, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /*U*/ 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*V*/ 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, + 0xc3, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, + /*W*/ 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xdb, + 0xdb, 0xff, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, + /*X*/ 0x00, 0x00, 0xc3, 0xc3, 0x66, 0x3c, 0x18, 0x18, + 0x3c, 0x66, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00, + /*Y*/ 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0x66, 0x3c, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /*Z*/ 0x00, 0x00, 0xff, 0xc3, 0x86, 0x0c, 0x18, 0x30, + 0x60, 0xc1, 0xc3, 0xff, 0x00, 0x00, 0x00, 0x00, + /*[*/ 0x00, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x3c, 0x00, 0x00, 0x00, 0x00, + /*\*/ 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0x70, 0x38, + 0x1c, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, + /*]*/ 0x00, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, + 0x0c, 0x0c, 0x0c, 0x3c, 0x00, 0x00, 0x00, 0x00, + /*^*/ 0x10, 0x38, 0x6c, 0xc6, 0x00, 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, 0x00, + /* */ 0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*a*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c, 0x7c, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /*b*/ 0x00, 0x00, 0xe0, 0x60, 0x60, 0x78, 0x6c, 0x66, + 0x66, 0x66, 0x66, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*c*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, + 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*d*/ 0x00, 0x00, 0x1c, 0x0c, 0x0c, 0x3c, 0x6c, 0xcc, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /*e*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xfe, + 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*f*/ 0x00, 0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, + 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, + /*g*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xcc, 0x78, 0x00, + /*h*/ 0x00, 0x00, 0xe0, 0x60, 0x60, 0x6c, 0x76, 0x66, + 0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00, + /*i*/ 0x00, 0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /*j*/ 0x00, 0x00, 0x06, 0x06, 0x00, 0x0e, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3c, 0x00, + /*k*/ 0x00, 0x00, 0xe0, 0x60, 0x60, 0x66, 0x6c, 0x78, + 0x78, 0x6c, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00, + /*l*/ 0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /*m*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6, 0xff, 0xdb, + 0xdb, 0xdb, 0xdb, 0xdb, 0x00, 0x00, 0x00, 0x00, + /*n*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, + /*o*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*p*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00, + /*q*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0x0c, 0x1e, 0x00, + /*r*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x76, 0x66, + 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, + /*s*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0x60, + 0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /*t*/ 0x00, 0x00, 0x10, 0x30, 0x30, 0xfc, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00, 0x00, + /*u*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /*v*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, + 0xc3, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, + /*w*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, + 0xdb, 0xdb, 0xff, 0x66, 0x00, 0x00, 0x00, 0x00, + /*x*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x66, 0x3c, + 0x18, 0x3c, 0x66, 0xc3, 0x00, 0x00, 0x00, 0x00, + /*y*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0xf8, 0x00, + /*z*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xcc, 0x18, + 0x30, 0x60, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, + /*{*/ 0x00, 0x00, 0x0e, 0x18, 0x18, 0x18, 0x70, 0x18, + 0x18, 0x18, 0x18, 0x0e, 0x00, 0x00, 0x00, 0x00, + /*|*/ 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /*}*/ 0x00, 0x00, 0x70, 0x18, 0x18, 0x18, 0x0e, 0x18, + 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00, + /*~*/ 0x00, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, + 0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xc0, + 0xc2, 0x66, 0x3c, 0x0c, 0x06, 0x7c, 0x00, 0x00, + /* */ 0x00, 0x00, 0xcc, 0x00, 0x00, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xfe, + 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x10, 0x38, 0x6c, 0x00, 0x78, 0x0c, 0x7c, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0xcc, 0x00, 0x00, 0x78, 0x0c, 0x7c, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x60, 0x30, 0x18, 0x00, 0x78, 0x0c, 0x7c, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x38, 0x6c, 0x38, 0x00, 0x78, 0x0c, 0x7c, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x60, 0x60, + 0x66, 0x3c, 0x0c, 0x06, 0x3c, 0x00, 0x00, 0x00, + /* */ 0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xfe, + 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0xc6, 0x00, 0x00, 0x7c, 0xc6, 0xfe, + 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xfe, + 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x66, 0x00, 0x00, 0x38, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x18, 0x3c, 0x66, 0x00, 0x38, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0xc6, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, + 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, + /* */ 0x38, 0x6c, 0x38, 0x00, 0x38, 0x6c, 0xc6, 0xc6, + 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, + /* */ 0x18, 0x30, 0x60, 0x00, 0xfe, 0x66, 0x60, 0x7c, + 0x60, 0x60, 0x66, 0xfe, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x3b, 0x1b, + 0x7e, 0xd8, 0xdc, 0x77, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x3e, 0x6c, 0xcc, 0xcc, 0xfe, 0xcc, + 0xcc, 0xcc, 0xcc, 0xce, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0xc6, 0x00, 0x00, 0x7c, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x30, 0x78, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x60, 0x30, 0x18, 0x00, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0xc6, 0x00, 0x00, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0x78, 0x00, + /* */ 0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0xc6, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x18, 0x18, 0x7e, 0xc3, 0xc0, 0xc0, 0xc0, + 0xc3, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, + 0x60, 0x60, 0xe6, 0xfc, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18, 0xff, 0x18, + 0xff, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0xfc, 0x66, 0x66, 0x7c, 0x62, 0x66, 0x6f, + 0x66, 0x66, 0x66, 0xf3, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x0e, 0x1b, 0x18, 0x18, 0x18, 0x7e, 0x18, + 0x18, 0x18, 0x18, 0x18, 0xd8, 0x70, 0x00, 0x00, + /* */ 0x00, 0x18, 0x30, 0x60, 0x00, 0x78, 0x0c, 0x7c, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x0c, 0x18, 0x30, 0x00, 0x38, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x18, 0x30, 0x60, 0x00, 0x7c, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x18, 0x30, 0x60, 0x00, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x76, 0xdc, 0x00, 0xdc, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, + /* */ 0x76, 0xdc, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, + 0xce, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x3c, 0x6c, 0x6c, 0x3e, 0x00, 0x7e, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x7c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x60, + 0xc0, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, + 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, + 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, + 0x60, 0xce, 0x9b, 0x06, 0x0c, 0x1f, 0x00, 0x00, + /* */ 0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, + 0x66, 0xce, 0x96, 0x3e, 0x06, 0x06, 0x00, 0x00, + /* */ 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, + 0x3c, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x6c, 0xd8, + 0x6c, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36, + 0x6c, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, + 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, + /* */ 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, + 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, + /* */ 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, + 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0xf8, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xf6, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0xf6, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xfe, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xfe, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3f, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x30, 0x37, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xf7, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xf7, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x1f, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0xff, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /* */ 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, + /* */ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + /* */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0xd8, + 0xd8, 0xd8, 0xdc, 0x76, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xd8, 0xcc, + 0xc6, 0xc6, 0xc6, 0xcc, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0, + 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0xfe, 0x6c, 0x6c, 0x6c, + 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0xfe, 0xc6, 0x60, 0x30, 0x18, + 0x30, 0x60, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xd8, 0xd8, + 0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, + 0x66, 0x7c, 0x60, 0x60, 0xc0, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x7e, 0x18, 0x3c, 0x66, 0x66, + 0x66, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, + 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x6c, + 0x6c, 0x6c, 0x6c, 0xee, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x1e, 0x30, 0x18, 0x0c, 0x3e, 0x66, + 0x66, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xdb, 0xdb, + 0xdb, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x03, 0x06, 0x7e, 0xdb, 0xdb, + 0xf3, 0x7e, 0x60, 0xc0, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x1c, 0x30, 0x60, 0x60, 0x7c, 0x60, + 0x60, 0x60, 0x30, 0x1c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, + 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, + 0x18, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x30, 0x18, 0x0c, 0x06, 0x0c, + 0x18, 0x30, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x60, 0x30, + 0x18, 0x0c, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x0e, 0x1b, 0x1b, 0x1b, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + /* */ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x7e, + 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, + 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, + 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x0f, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xec, + 0x6c, 0x6c, 0x3c, 0x1c, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0xd8, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x70, 0xd8, 0x30, 0x60, 0xc8, 0xf8, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x7c, 0x7c, 0x7c, 0x7c, + 0x7c, 0x7c, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, + /* */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; diff --git a/kernel/graphics/fonts/font_ter_16x32.h b/kernel/graphics/fonts/font_ter_16x32.h new file mode 100644 index 0000000..040875a --- /dev/null +++ b/kernel/graphics/fonts/font_ter_16x32.h @@ -0,0 +1,1542 @@ + +// SPDX-License-Identifier: GPL-2.0 +static const unsigned char fontdata_ter16x32[] = { + + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x3f, 0xf8, 0x7f, 0xfc, 0xf0, 0x1e, 0xe0, 0x0e, 0xe0, 0x0e, + 0xe0, 0x0e, 0xee, 0xee, 0xee, 0xee, 0xe0, 0x0e, 0xe0, 0x0e, 0xe0, + 0x0e, 0xe0, 0x0e, 0xef, 0xee, 0xe7, 0xce, 0xe0, 0x0e, 0xe0, 0x0e, + 0xe0, 0x0e, 0xf0, 0x1e, 0x7f, 0xfc, 0x3f, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x3f, 0xf8, 0x7f, 0xfc, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, + 0xff, 0xfe, 0xe3, 0x8e, 0xe3, 0x8e, 0xff, 0xfe, 0xff, 0xfe, 0xff, + 0xfe, 0xff, 0xfe, 0xe0, 0x0e, 0xf0, 0x1e, 0xf8, 0x3e, 0xff, 0xfe, + 0xff, 0xfe, 0xff, 0xfe, 0x7f, 0xfc, 0x3f, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 2 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x3c, 0xfc, 0x7e, 0xfe, 0xfe, + 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0x7f, + 0xfc, 0x7f, 0xfc, 0x3f, 0xf8, 0x1f, 0xf0, 0x0f, 0xe0, 0x07, 0xc0, + 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 3 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x07, 0xc0, + 0x0f, 0xe0, 0x1f, 0xf0, 0x3f, 0xf8, 0x7f, 0xfc, 0xff, 0xfe, 0xff, + 0xfe, 0x7f, 0xfc, 0x3f, 0xf8, 0x1f, 0xf0, 0x0f, 0xe0, 0x07, 0xc0, + 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 4 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x07, 0xc0, 0x0f, 0xe0, 0x0f, 0xe0, 0x0f, 0xe0, 0x0f, 0xe0, + 0x0f, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x3b, 0xb8, 0x7f, 0xfc, 0xff, + 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0x7f, 0xfc, 0x3b, 0xb8, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 5 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x03, 0x80, 0x07, 0xc0, 0x0f, 0xe0, 0x1f, 0xf0, + 0x3f, 0xf8, 0x7f, 0xfc, 0x7f, 0xfc, 0xff, 0xfe, 0xff, 0xfe, 0xff, + 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0x7b, 0xbc, 0x3b, 0xb8, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x03, 0xc0, 0x07, 0xe0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, + 0xf0, 0x0f, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 7 */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x3f, 0xf8, 0x1f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, + 0x0f, 0xf0, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 8 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x03, 0xc0, 0x07, 0xe0, 0x0e, 0x70, 0x0c, 0x30, 0x0c, + 0x30, 0x0e, 0x70, 0x07, 0xe0, 0x03, 0xc0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 9 */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x3f, 0xf8, 0x1f, 0xf1, 0x8f, 0xf3, 0xcf, 0xf3, + 0xcf, 0xf1, 0x8f, 0xf8, 0x1f, 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 10 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0xfe, 0x03, 0xfe, 0x00, 0x1e, 0x00, 0x3e, 0x00, 0x76, + 0x00, 0xe6, 0x01, 0xc6, 0x03, 0x86, 0x3f, 0xe0, 0x7f, 0xf0, 0xf0, + 0x78, 0xe0, 0x38, 0xe0, 0x38, 0xe0, 0x38, 0xe0, 0x38, 0xe0, 0x38, + 0xe0, 0x38, 0xf0, 0x78, 0x7f, 0xf0, 0x3f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 11 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, + 0xf0, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x7f, 0xfc, 0x7f, 0xfc, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 12 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x3f, 0xfc, 0x3f, 0xfc, 0x38, 0x1c, 0x38, 0x1c, 0x38, 0x1c, + 0x38, 0x1c, 0x3f, 0xfc, 0x3f, 0xfc, 0x38, 0x00, 0x38, 0x00, 0x38, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, + 0x38, 0x00, 0x38, 0x00, 0xf8, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 13 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x7f, 0xfe, 0x7f, 0xfe, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x3e, 0xf0, 0x3c, 0xe0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 14 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x73, 0x9c, + 0x73, 0x9c, 0x3b, 0xb8, 0x1f, 0xf0, 0x0f, 0xe0, 0x7c, 0x7c, 0x7c, + 0x7c, 0x0f, 0xe0, 0x1f, 0xf0, 0x3b, 0xb8, 0x73, 0x9c, 0x73, 0x9c, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 15 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xf0, 0x00, 0xfc, 0x00, + 0xff, 0x00, 0xff, 0xc0, 0xff, 0xf0, 0xff, 0xfc, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0xff, 0xf0, 0xff, 0xc0, 0xff, 0x00, 0xfc, 0x00, + 0xf0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 16 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x0f, 0x00, 0x3f, + 0x00, 0xff, 0x03, 0xff, 0x0f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x3f, 0xff, 0x0f, 0xff, 0x03, 0xff, 0x00, 0xff, 0x00, 0x3f, + 0x00, 0x0f, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 17 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0f, 0xe0, 0x1f, 0xf0, 0x3b, 0xb8, + 0x73, 0x9c, 0x63, 0x8c, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x63, 0x8c, 0x73, 0x9c, 0x3b, 0xb8, + 0x1f, 0xf0, 0x0f, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 18 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 19 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xfe, 0x3f, 0xfe, 0x79, 0xce, 0x71, 0xce, 0x71, 0xce, + 0x71, 0xce, 0x71, 0xce, 0x71, 0xce, 0x79, 0xce, 0x3f, 0xce, 0x1f, + 0xce, 0x01, 0xce, 0x01, 0xce, 0x01, 0xce, 0x01, 0xce, 0x01, 0xce, + 0x01, 0xce, 0x01, 0xce, 0x01, 0xce, 0x01, 0xce, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 20 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xe0, 0x0f, + 0xf0, 0x1e, 0x78, 0x1c, 0x38, 0x1c, 0x00, 0x1e, 0x00, 0x0f, 0xc0, + 0x0f, 0xe0, 0x1c, 0xf0, 0x1c, 0x78, 0x1c, 0x38, 0x1c, 0x38, 0x1c, + 0x38, 0x1e, 0x38, 0x0f, 0x38, 0x07, 0xf0, 0x03, 0xf0, 0x00, 0x78, + 0x00, 0x38, 0x1c, 0x38, 0x1e, 0x78, 0x0f, 0xf0, 0x07, 0xe0, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 21 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, + 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 22 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0f, 0xe0, 0x1f, 0xf0, 0x3b, 0xb8, + 0x73, 0x9c, 0x63, 0x8c, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x63, 0x8c, 0x73, 0x9c, 0x3b, 0xb8, 0x1f, 0xf0, 0x0f, 0xe0, + 0x07, 0xc0, 0x03, 0x80, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 23 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0f, 0xe0, 0x1f, 0xf0, 0x3b, 0xb8, + 0x73, 0x9c, 0x63, 0x8c, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 24 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x63, 0x8c, 0x73, 0x9c, 0x3b, 0xb8, + 0x1f, 0xf0, 0x0f, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 25 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xe0, + 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, + 0xfe, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 26 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x07, 0x00, + 0x0e, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, + 0xfe, 0x38, 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 27 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x60, 0x0e, 0x70, + 0x1c, 0x38, 0x38, 0x1c, 0x70, 0x0e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x70, 0x0e, 0x38, 0x1c, 0x1c, 0x38, 0x0e, 0x70, 0x06, 0x60, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 29 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0x80, 0x03, 0xc0, + 0x03, 0xc0, 0x07, 0xe0, 0x07, 0xe0, 0x0f, 0xf0, 0x0f, 0xf0, 0x1f, + 0xf8, 0x1f, 0xf8, 0x3f, 0xfc, 0x3f, 0xfc, 0x7f, 0xfe, 0x7f, 0xfe, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 30 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfe, + 0x7f, 0xfe, 0x3f, 0xfc, 0x3f, 0xfc, 0x1f, 0xf8, 0x1f, 0xf8, 0x0f, + 0xf0, 0x0f, 0xf0, 0x07, 0xe0, 0x07, 0xe0, 0x03, 0xc0, 0x03, 0xc0, + 0x01, 0x80, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 31 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 32 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 33 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 34 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x7f, 0xfc, 0x7f, 0xfc, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x7f, 0xfc, 0x7f, 0xfc, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 35 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x1f, 0xf0, 0x3f, 0xf8, 0x7b, 0xbc, 0x73, 0x9c, + 0x73, 0x80, 0x73, 0x80, 0x73, 0x80, 0x7b, 0x80, 0x3f, 0xf0, 0x1f, + 0xf8, 0x03, 0xbc, 0x03, 0x9c, 0x03, 0x9c, 0x03, 0x9c, 0x73, 0x9c, + 0x7b, 0xbc, 0x3f, 0xf8, 0x1f, 0xf0, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 36 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0x1c, 0x3f, 0x9c, 0x3b, 0xb8, 0x3b, 0xb8, 0x3f, 0xf0, + 0x1f, 0x70, 0x00, 0xe0, 0x00, 0xe0, 0x01, 0xc0, 0x01, 0xc0, 0x03, + 0x80, 0x03, 0x80, 0x07, 0x00, 0x07, 0x00, 0x0e, 0xf8, 0x0f, 0xfc, + 0x1d, 0xdc, 0x1d, 0xdc, 0x39, 0xfc, 0x38, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 37 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0f, 0xc0, 0x1f, 0xe0, 0x38, 0x70, 0x38, 0x70, 0x38, 0x70, + 0x38, 0x70, 0x38, 0x70, 0x1c, 0xe0, 0x0f, 0xc0, 0x0f, 0x80, 0x1f, + 0xce, 0x38, 0xee, 0x70, 0x7c, 0x70, 0x38, 0x70, 0x38, 0x70, 0x38, + 0x70, 0x38, 0x78, 0x7c, 0x3f, 0xee, 0x1f, 0xce, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 39 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x07, 0x00, 0x07, 0x00, + 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, + 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x03, 0x80, 0x01, 0xc0, 0x00, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 40 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xc0, 0x01, 0xc0, + 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xe0, 0x00, + 0xe0, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xe0, 0x01, 0xc0, + 0x01, 0xc0, 0x03, 0x80, 0x07, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 41 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, + 0x1c, 0x70, 0x0e, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x7f, 0xfc, 0x7f, + 0xfc, 0x03, 0x80, 0x07, 0xc0, 0x0e, 0xe0, 0x1c, 0x70, 0x38, 0x38, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 42 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x7f, 0xfc, 0x7f, + 0xfc, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 43 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, 0x0e, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 44 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x7f, + 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 45 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 46 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x38, 0x00, 0x70, + 0x00, 0x70, 0x00, 0xe0, 0x00, 0xe0, 0x01, 0xc0, 0x01, 0xc0, 0x03, + 0x80, 0x03, 0x80, 0x07, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x0e, 0x00, + 0x1c, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 47 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x3c, 0x70, 0x7c, 0x70, 0xfc, 0x71, 0xdc, 0x73, 0x9c, 0x77, + 0x1c, 0x7e, 0x1c, 0x7c, 0x1c, 0x78, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 48 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0x80, 0x0f, 0x80, 0x1f, 0x80, 0x1f, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x1f, 0xf0, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 49 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x70, 0x00, + 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x07, 0x00, 0x0e, 0x00, 0x1c, 0x00, + 0x38, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 50 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x3c, 0x0f, 0xf8, 0x0f, + 0xf8, 0x00, 0x3c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 51 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0x00, 0x3c, 0x00, 0x7c, 0x00, 0xfc, 0x01, 0xdc, + 0x03, 0x9c, 0x07, 0x1c, 0x0e, 0x1c, 0x1c, 0x1c, 0x38, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x1c, + 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 52 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x00, + 0x3c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 53 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf8, 0x3f, 0xf8, 0x78, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, + 0x3c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 54 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x38, 0x00, 0x38, 0x00, 0x70, 0x00, 0x70, 0x00, 0xe0, 0x00, + 0xe0, 0x01, 0xc0, 0x01, 0xc0, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 55 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x3f, + 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 56 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x78, 0x1c, 0x3f, + 0xfc, 0x1f, 0xfc, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, + 0x00, 0x1c, 0x00, 0x3c, 0x3f, 0xf8, 0x3f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 57 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 58 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, 0x0e, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 59 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, + 0x03, 0x80, 0x07, 0x00, 0x0e, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x38, + 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xc0, + 0x00, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 60 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 61 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x38, 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, + 0x01, 0xc0, 0x00, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00, + 0x1c, 0x00, 0x38, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, + 0x07, 0x00, 0x0e, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 62 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x38, 0x00, 0x70, 0x00, 0xe0, 0x01, + 0xc0, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 63 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf8, 0x3f, 0xfc, 0x78, 0x0e, 0x70, 0x06, 0x71, 0xfe, + 0x73, 0xfe, 0x77, 0x8e, 0x77, 0x0e, 0x77, 0x0e, 0x77, 0x0e, 0x77, + 0x0e, 0x77, 0x0e, 0x77, 0x0e, 0x77, 0x9e, 0x73, 0xfe, 0x71, 0xf6, + 0x70, 0x00, 0x78, 0x00, 0x3f, 0xfe, 0x1f, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 64 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x7f, + 0xfc, 0x7f, 0xfc, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 65 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x38, 0x7f, 0xf0, 0x7f, 0xf0, 0x70, + 0x38, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x3c, 0x7f, 0xf8, 0x7f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 66 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 67 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xc0, 0x7f, 0xf0, 0x70, 0x78, 0x70, 0x38, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x38, 0x70, 0x78, 0x7f, 0xf0, 0x7f, 0xc0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 68 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x7f, 0xe0, 0x7f, + 0xe0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 69 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x7f, 0xe0, 0x7f, + 0xe0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 70 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x71, 0xfc, 0x71, + 0xfc, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 71 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x7f, 0xfc, 0x7f, + 0xfc, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 72 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0f, 0xe0, 0x0f, 0xe0, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 73 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, + 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x70, 0x38, 0x70, 0x38, + 0x70, 0x38, 0x78, 0x78, 0x3f, 0xf0, 0x1f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 74 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x0c, 0x70, 0x1c, 0x70, 0x38, 0x70, 0x70, 0x70, 0xe0, + 0x71, 0xc0, 0x73, 0x80, 0x77, 0x00, 0x7e, 0x00, 0x7c, 0x00, 0x7c, + 0x00, 0x7e, 0x00, 0x77, 0x00, 0x73, 0x80, 0x71, 0xc0, 0x70, 0xe0, + 0x70, 0x70, 0x70, 0x38, 0x70, 0x1c, 0x70, 0x0c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 75 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 76 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x0e, 0x70, 0x0e, 0x78, 0x1e, 0x7c, 0x3e, 0x7e, 0x7e, + 0x7e, 0x7e, 0x77, 0xee, 0x73, 0xce, 0x73, 0xce, 0x71, 0x8e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 77 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x78, 0x1c, 0x7c, 0x1c, 0x7e, 0x1c, 0x77, 0x1c, 0x73, 0x9c, 0x71, + 0xdc, 0x70, 0xfc, 0x70, 0x7c, 0x70, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 78 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 79 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x3c, 0x7f, + 0xf8, 0x7f, 0xf0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 80 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x73, 0x9c, 0x79, 0xfc, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x38, 0x00, + 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 81 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x3c, 0x7f, + 0xf8, 0x7f, 0xf0, 0x7e, 0x00, 0x77, 0x00, 0x73, 0x80, 0x71, 0xc0, + 0x70, 0xe0, 0x70, 0x70, 0x70, 0x38, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 82 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x78, 0x00, 0x3f, 0xf0, 0x1f, + 0xf8, 0x00, 0x3c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 83 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 84 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 85 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x0e, 0xe0, 0x0e, 0xe0, + 0x0e, 0xe0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 86 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x71, + 0x8e, 0x73, 0xce, 0x73, 0xce, 0x77, 0xee, 0x7e, 0x7e, 0x7e, 0x7e, + 0x7c, 0x3e, 0x78, 0x1e, 0x70, 0x0e, 0x70, 0x0e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 87 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x38, 0x38, 0x38, 0x38, 0x1c, 0x70, + 0x1c, 0x70, 0x0e, 0xe0, 0x0e, 0xe0, 0x07, 0xc0, 0x07, 0xc0, 0x07, + 0xc0, 0x07, 0xc0, 0x0e, 0xe0, 0x0e, 0xe0, 0x1c, 0x70, 0x1c, 0x70, + 0x38, 0x38, 0x38, 0x38, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 88 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x38, 0x38, 0x38, 0x38, + 0x1c, 0x70, 0x1c, 0x70, 0x0e, 0xe0, 0x0e, 0xe0, 0x07, 0xc0, 0x07, + 0xc0, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 89 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, + 0x00, 0x38, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x07, + 0x00, 0x0e, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 90 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0f, 0xf0, 0x0f, 0xf0, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, + 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, + 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, + 0x0e, 0x00, 0x0e, 0x00, 0x0f, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 91 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x0e, 0x00, + 0x0e, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x80, 0x03, 0x80, 0x01, + 0xc0, 0x01, 0xc0, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 92 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0f, 0xf0, 0x0f, 0xf0, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x0f, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 93 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x07, + 0xc0, 0x0e, 0xe0, 0x1c, 0x70, 0x38, 0x38, 0x70, 0x1c, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 94 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, + 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 95 */ + 0x00, 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 96 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x3f, 0xf0, 0x3f, 0xf8, 0x00, 0x3c, 0x00, 0x1c, 0x00, + 0x1c, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 97 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x3c, 0x7f, 0xf8, 0x7f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 98 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 99 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, + 0x00, 0x1c, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 100 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 101 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xfe, 0x01, 0xfe, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x3f, 0xf8, 0x3f, 0xf8, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 102 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x1c, 0x00, + 0x1c, 0x00, 0x3c, 0x3f, 0xf8, 0x3f, 0xf0, 0x00, 0x00, /* 103 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 104 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x0f, 0x80, 0x0f, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 105 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xf8, 0x00, 0xf8, 0x00, 0x38, 0x00, 0x38, 0x00, + 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x38, 0x38, 0x38, + 0x38, 0x3c, 0x78, 0x1f, 0xf0, 0x0f, 0xe0, 0x00, 0x00, /* 106 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, + 0x38, 0x00, 0x38, 0x1c, 0x38, 0x38, 0x38, 0x70, 0x38, 0xe0, 0x39, + 0xc0, 0x3b, 0x80, 0x3f, 0x00, 0x3f, 0x00, 0x3b, 0x80, 0x39, 0xc0, + 0x38, 0xe0, 0x38, 0x70, 0x38, 0x38, 0x38, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 107 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0f, 0x80, 0x0f, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 108 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x73, 0xbc, 0x73, 0x9c, 0x73, + 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, + 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 109 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 110 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 111 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x3c, 0x7f, 0xf8, 0x7f, 0xf0, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, /* 112 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x1c, 0x00, + 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x00, /* 113 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x73, 0xfc, 0x77, 0xfc, 0x7e, 0x00, 0x7c, 0x00, 0x78, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 114 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x00, 0x70, + 0x00, 0x78, 0x00, 0x3f, 0xf0, 0x1f, 0xf8, 0x00, 0x3c, 0x00, 0x1c, + 0x00, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 115 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x7f, 0xf0, 0x7f, 0xf0, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x80, 0x03, 0xfc, 0x01, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 116 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 117 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x38, 0x38, 0x38, + 0x38, 0x38, 0x38, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x0e, 0xe0, + 0x0e, 0xe0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 118 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x73, + 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, + 0x73, 0x9c, 0x7b, 0xbc, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 119 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x38, 0x38, 0x1c, + 0x70, 0x0e, 0xe0, 0x07, 0xc0, 0x07, 0xc0, 0x0e, 0xe0, 0x1c, 0x70, + 0x38, 0x38, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 120 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x1c, 0x00, + 0x1c, 0x00, 0x3c, 0x3f, 0xf8, 0x3f, 0xf0, 0x00, 0x00, /* 121 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x38, 0x00, 0x70, 0x00, + 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x07, 0x00, 0x0e, 0x00, 0x1c, 0x00, + 0x38, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 122 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0xf0, 0x03, 0xf0, 0x07, 0x80, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x3e, 0x00, 0x3e, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x80, 0x03, 0xf0, 0x01, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 123 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 124 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x3e, 0x00, 0x3f, 0x00, 0x07, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x01, 0xf0, 0x01, + 0xf0, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x07, 0x80, 0x3f, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 125 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x1c, 0x3f, + 0x1c, 0x77, 0x9c, 0x73, 0xdc, 0x71, 0xf8, 0x70, 0xf0, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 126 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, + 0x07, 0xc0, 0x0f, 0xe0, 0x1e, 0xf0, 0x3c, 0x78, 0x78, 0x3c, 0xf0, + 0x1e, 0xe0, 0x0e, 0xe0, 0x0e, 0xe0, 0x0e, 0xe0, 0x0e, 0xe0, 0x0e, + 0xe0, 0x0e, 0xe0, 0x0e, 0xff, 0xfe, 0xff, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 127 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x07, 0x00, 0x0e, 0x00, 0x00, 0x00, /* 128 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 129 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 130 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0e, 0xe0, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x3f, 0xf0, 0x3f, 0xf8, 0x00, 0x3c, 0x00, 0x1c, 0x00, + 0x1c, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 131 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x3f, 0xf0, 0x3f, 0xf8, 0x00, 0x3c, 0x00, 0x1c, 0x00, + 0x1c, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 132 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x3f, 0xf0, 0x3f, 0xf8, 0x00, 0x3c, 0x00, 0x1c, 0x00, + 0x1c, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 133 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x07, 0xc0, 0x0e, 0xe0, 0x0e, 0xe0, 0x0e, 0xe0, 0x07, 0xc0, + 0x00, 0x00, 0x3f, 0xf0, 0x3f, 0xf8, 0x00, 0x3c, 0x00, 0x1c, 0x00, + 0x1c, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 134 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x07, 0x00, 0x0e, 0x00, 0x00, 0x00, /* 135 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0e, 0xe0, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 136 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 137 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 138 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x0f, 0x80, 0x0f, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 139 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0e, 0xe0, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x0f, 0x80, 0x0f, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 140 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x0f, 0x80, 0x0f, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 141 */ + 0x00, 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x7f, + 0xfc, 0x7f, 0xfc, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 142 */ + 0x00, 0x00, 0x07, 0xc0, 0x0e, 0xe0, 0x0e, 0xe0, 0x0e, 0xe0, 0x07, + 0xc0, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x7f, + 0xfc, 0x7f, 0xfc, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 143 */ + 0x00, 0x00, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x7f, 0xe0, 0x7f, + 0xe0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 144 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xf8, 0x7f, 0xfc, 0x03, 0x9e, 0x03, 0x8e, 0x03, + 0x8e, 0x3f, 0x8e, 0x7f, 0xfe, 0xf3, 0xfe, 0xe3, 0x80, 0xe3, 0x80, + 0xe3, 0x80, 0xf3, 0xce, 0x7f, 0xfe, 0x3e, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 145 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x3f, 0xfe, 0x7f, 0xfe, 0xf1, 0xc0, 0xe1, 0xc0, 0xe1, 0xc0, + 0xe1, 0xc0, 0xe1, 0xc0, 0xe1, 0xc0, 0xe1, 0xc0, 0xff, 0xfe, 0xff, + 0xfe, 0xe1, 0xc0, 0xe1, 0xc0, 0xe1, 0xc0, 0xe1, 0xc0, 0xe1, 0xc0, + 0xe1, 0xc0, 0xe1, 0xc0, 0xe1, 0xfe, 0xe1, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 146 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0e, 0xe0, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 147 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 148 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 149 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0e, 0xe0, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 150 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 151 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x1c, 0x00, + 0x1c, 0x00, 0x3c, 0x3f, 0xf8, 0x3f, 0xf0, 0x00, 0x00, /* 152 */ + 0x00, 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 153 */ + 0x00, 0x00, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 154 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x1f, 0xf0, 0x3f, 0xf8, 0x7b, 0xbc, 0x73, 0x9c, 0x73, + 0x80, 0x73, 0x80, 0x73, 0x80, 0x73, 0x80, 0x73, 0x80, 0x73, 0x80, + 0x73, 0x9c, 0x7b, 0xbc, 0x3f, 0xf8, 0x1f, 0xf0, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 155 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x07, 0xe0, 0x0f, 0xf0, 0x1e, 0x78, 0x1c, 0x38, 0x1c, 0x00, + 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x7f, 0xe0, 0x7f, + 0xe0, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, + 0x1c, 0x1c, 0x1c, 0x1c, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 156 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x38, 0x38, 0x38, 0x38, 0x1c, 0x70, + 0x1c, 0x70, 0x0e, 0xe0, 0x0e, 0xe0, 0x07, 0xc0, 0x07, 0xc0, 0x03, + 0x80, 0x03, 0x80, 0x3f, 0xf8, 0x3f, 0xf8, 0x03, 0x80, 0x03, 0x80, + 0x3f, 0xf8, 0x3f, 0xf8, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 157 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0x80, 0xe3, 0xc0, 0xe1, 0xc0, 0xe1, 0xc0, + 0xe1, 0xc0, 0xe1, 0xc0, 0xe1, 0xc0, 0xe3, 0xc0, 0xff, 0xf0, 0xff, + 0x70, 0xe0, 0x70, 0xe3, 0xfe, 0xe3, 0xfe, 0xe0, 0x70, 0xe0, 0x70, + 0xe0, 0x70, 0xe0, 0x70, 0xe0, 0x7e, 0xe0, 0x3e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 158 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0xf8, 0x03, 0xfc, 0x03, 0x9c, 0x03, 0x9c, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x1f, 0xf0, 0x1f, 0xf0, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x73, 0x80, 0x73, + 0x80, 0x7f, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, /* 159 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x3f, 0xf0, 0x3f, 0xf8, 0x00, 0x3c, 0x00, 0x1c, 0x00, + 0x1c, 0x1f, 0xfc, 0x3f, 0xfc, 0x78, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 160 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x0f, 0x80, 0x0f, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x0f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 161 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 162 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x1c, 0x3f, 0xfc, 0x1f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 163 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0x38, 0x3b, 0xb8, 0x3b, 0xb8, 0x39, 0xf0, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xf0, 0x7f, 0xf8, 0x70, 0x3c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 164 */ + 0x00, 0x00, 0x1f, 0x38, 0x3b, 0xb8, 0x3b, 0xb8, 0x39, 0xf0, 0x00, + 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x78, 0x1c, 0x7c, 0x1c, 0x7e, 0x1c, 0x77, 0x1c, 0x73, 0x9c, 0x71, + 0xdc, 0x70, 0xfc, 0x70, 0x7c, 0x70, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 165 */ + 0x00, 0x00, 0x00, 0x00, 0x1f, 0xe0, 0x1f, 0xf0, 0x00, 0x38, 0x00, + 0x38, 0x0f, 0xf8, 0x1f, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, + 0x1f, 0xf8, 0x0f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xf8, 0x3f, + 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 166 */ + 0x00, 0x00, 0x00, 0x00, 0x0f, 0xe0, 0x1f, 0xf0, 0x38, 0x38, 0x38, + 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, + 0x1f, 0xf0, 0x0f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xf8, 0x3f, + 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 167 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, 0x0e, + 0x00, 0x1c, 0x00, 0x38, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 168 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 169 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x1c, 0x00, 0x1c, 0x00, + 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 170 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x00, 0x3c, 0x00, 0x7c, 0x06, 0x1c, 0x0e, 0x1c, 0x1c, + 0x1c, 0x38, 0x1c, 0x70, 0x1c, 0xe0, 0x1d, 0xc0, 0x03, 0x80, 0x07, + 0x00, 0x0e, 0xfc, 0x1d, 0xfe, 0x39, 0xce, 0x71, 0xce, 0x60, 0x1c, + 0x00, 0x38, 0x00, 0x70, 0x00, 0xfe, 0x01, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 171 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0e, 0x00, 0x1e, 0x00, 0x3e, 0x00, 0x0e, 0x00, 0x0e, 0x06, + 0x0e, 0x0e, 0x0e, 0x1c, 0x0e, 0x38, 0x0e, 0x70, 0x00, 0xe0, 0x01, + 0xce, 0x03, 0x9e, 0x07, 0x3e, 0x0e, 0x7e, 0x1c, 0xee, 0x39, 0xce, + 0x73, 0xfe, 0x63, 0xfe, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 172 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 173 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0xce, 0x03, 0x9c, 0x07, 0x38, 0x0e, 0x70, 0x1c, + 0xe0, 0x39, 0xc0, 0x73, 0x80, 0x73, 0x80, 0x39, 0xc0, 0x1c, 0xe0, + 0x0e, 0x70, 0x07, 0x38, 0x03, 0x9c, 0x01, 0xce, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 174 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x73, 0x80, 0x39, 0xc0, 0x1c, 0xe0, 0x0e, 0x70, 0x07, + 0x38, 0x03, 0x9c, 0x01, 0xce, 0x01, 0xce, 0x03, 0x9c, 0x07, 0x38, + 0x0e, 0x70, 0x1c, 0xe0, 0x39, 0xc0, 0x73, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 175 */ + 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, + 0x00, 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, + 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, 0xaa, + 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, + 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, + 0x00, 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, /* 176 */ + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, /* 177 */ + 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, + 0xaa, 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, + 0xaa, 0xaa, 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, 0xaa, 0xff, + 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, 0xaa, + 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, + 0xaa, 0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff, 0xaa, 0xaa, /* 178 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 179 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 180 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x03, 0x80, 0x03, + 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 181 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0xfe, 0x70, 0xfe, 0x70, 0xfe, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 182 */ + 0x00, 0x00, 0x00, 0x00, 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, 0xf0, 0xff, 0xf0, 0xff, + 0xf0, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 183 */ + 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, 0x80, 0xff, 0x80, 0xff, 0x80, 0x03, 0x80, 0x03, + 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 184 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0xfe, 0x70, 0xfe, 0x70, 0xfe, 0x70, 0x00, 0x70, 0x00, + 0x70, 0xfe, 0x70, 0xfe, 0x70, 0xfe, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 185 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 186 */ + 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, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0x00, 0x70, 0x00, + 0x70, 0xfe, 0x70, 0xfe, 0x70, 0xfe, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 187 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0xfe, 0x70, 0xfe, 0x70, 0xfe, 0x70, 0x00, 0x70, 0x00, + 0x70, 0xff, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 188 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0xff, 0xf0, 0xff, 0xf0, 0xff, + 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 189 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x03, 0x80, 0x03, + 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 190 */ + 0x00, 0x00, 0x00, 0x00, 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, 0x80, 0xff, 0x80, 0xff, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 191 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0xff, 0x03, 0xff, 0x03, + 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, /* 192 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, + 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, /* 193 */ + 0x00, 0x00, 0x00, 0x00, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 194 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0xff, 0x03, 0xff, 0x03, + 0xff, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 195 */ + 0x00, 0x00, 0x00, 0x00, 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, 0xff, 0xff, 0xff, 0xff, + 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, /* 196 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 197 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0x80, 0x03, + 0x80, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 198 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, + 0x7f, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 199 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, 0x00, 0x0e, + 0x00, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 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, /* 200 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0e, 0x00, 0x0e, + 0x00, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 201 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 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, /* 202 */ + 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 203 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, 0x00, 0x0e, + 0x00, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, 0x7f, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 204 */ + 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 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, /* 205 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0x00, 0x00, 0x00, + 0x00, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 206 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 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, /* 207 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0xff, 0xff, 0xff, 0xff, 0xff, + 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, /* 208 */ + 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 209 */ + 0x00, 0x00, 0x00, 0x00, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 210 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0f, 0xff, 0x0f, 0xff, 0x0f, + 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, /* 211 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0x80, 0x03, + 0x80, 0x03, 0xff, 0x03, 0xff, 0x03, 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, /* 212 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0x80, 0x03, + 0x80, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 213 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0x0f, 0xff, 0x0f, + 0xff, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 214 */ + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, + 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, + 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, 0x0e, 0x70, /* 215 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x80, 0x03, + 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 216 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, + 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 217 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0x03, 0xff, 0x03, + 0xff, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 218 */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 219 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 220 */ + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, + 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, + 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, + 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, /* 221 */ + 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, + 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, + 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, /* 222 */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 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, /* 223 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xee, 0x3f, 0xfe, 0x78, 0x3c, 0x70, 0x38, 0x70, + 0x38, 0x70, 0x38, 0x70, 0x38, 0x70, 0x38, 0x70, 0x38, 0x70, 0x38, + 0x70, 0x38, 0x78, 0x3c, 0x3f, 0xfe, 0x1f, 0xee, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 224 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x3f, 0xe0, 0x7f, 0xf0, 0x70, 0x78, 0x70, 0x38, 0x70, 0x38, + 0x70, 0x38, 0x70, 0x38, 0x70, 0x70, 0x7f, 0xf0, 0x7f, 0xf0, 0x70, + 0x38, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x3c, 0x7f, 0xf8, 0x7f, 0xf0, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, /* 225 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, + 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 226 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 227 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00, + 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xc0, 0x00, 0xe0, 0x00, + 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x07, 0x00, 0x0e, 0x00, 0x1c, 0x00, + 0x38, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 228 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1f, 0xfe, 0x3f, 0xfe, 0x78, 0xf0, 0x70, 0x78, 0x70, + 0x3c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 229 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x3c, + 0x70, 0x7c, 0x70, 0xfc, 0x7f, 0xdc, 0x7f, 0x9c, 0x70, 0x00, 0x70, + 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, /* 230 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0xc0, 0x01, 0xf8, 0x00, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 231 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x80, 0x03, 0x80, 0x1f, 0xf0, 0x3f, 0xf8, 0x7b, 0xbc, + 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, + 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x7b, 0xbc, + 0x3f, 0xf8, 0x1f, 0xf0, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 232 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x77, 0xdc, 0x77, + 0xdc, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 233 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x3f, 0xf8, 0x78, 0x3c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x38, 0x38, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x7c, 0x7c, 0x7c, 0x7c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 234 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1f, 0xf0, 0x1f, 0xf0, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, + 0x01, 0xc0, 0x0f, 0xe0, 0x1f, 0xf0, 0x38, 0x38, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x78, 0x3c, 0x3f, 0xf8, 0x1f, 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 235 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3e, 0xf8, 0x7f, 0xfc, 0xe7, 0xce, 0xe3, 0x8e, 0xe3, 0x8e, 0xe3, + 0x8e, 0xe3, 0x8e, 0xe7, 0xce, 0x7f, 0xfc, 0x3e, 0xf8, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 236 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x38, 0x0f, 0xf0, + 0x1f, 0xf8, 0x38, 0xfc, 0x38, 0xfc, 0x39, 0xdc, 0x39, 0xdc, 0x3b, + 0x9c, 0x3b, 0x9c, 0x3f, 0x1c, 0x3f, 0x1c, 0x1f, 0xf8, 0x0f, 0xf0, + 0x1c, 0x00, 0x1c, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 237 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xfc, 0x1f, 0xfc, + 0x3c, 0x00, 0x38, 0x00, 0x70, 0x00, 0x70, 0x00, 0x7f, 0xfc, 0x7f, + 0xfc, 0x70, 0x00, 0x70, 0x00, 0x38, 0x00, 0x3c, 0x00, 0x1f, 0xfc, + 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 238 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xc0, + 0x1f, 0xf0, 0x3c, 0x78, 0x38, 0x38, 0x70, 0x1c, 0x70, 0x1c, 0x70, + 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, + 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 239 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x7f, + 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, + 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 240 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x7f, 0xfc, 0x7f, + 0xfc, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x7f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 241 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xc0, + 0x00, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x38, 0x00, 0x70, 0x00, + 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x07, 0x00, 0x0e, 0x00, 0x1c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3f, 0xfc, 0x3f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 242 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x38, 0x00, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, + 0x07, 0x00, 0x0e, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, + 0x00, 0x03, 0x80, 0x01, 0xc0, 0x00, 0xe0, 0x00, 0x70, 0x00, 0x38, + 0x00, 0x00, 0x00, 0x00, 0x3f, 0xfc, 0x3f, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 243 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0xf8, 0x03, 0xfc, 0x03, 0x9c, 0x03, 0x9c, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, /* 244 */ + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x73, 0x80, 0x73, 0x80, 0x7f, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 245 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x7f, + 0xfc, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 246 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3e, 0x1c, 0x7f, 0xbc, 0x7b, 0xfc, 0x70, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x3e, 0x1c, 0x7f, 0xbc, 0x7b, 0xfc, 0x70, 0xf8, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 247 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xe0, 0x1f, + 0xf0, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1c, 0x70, 0x1f, 0xf0, + 0x0f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 248 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x07, 0xe0, 0x07, 0xe0, 0x07, + 0xe0, 0x07, 0xe0, 0x03, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 249 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, + 0x80, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 250 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x3e, 0x00, + 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x70, 0x38, 0x70, + 0x38, 0x70, 0x38, 0x78, 0x38, 0x3c, 0x38, 0x1e, 0x38, 0x0f, 0x38, + 0x07, 0xb8, 0x03, 0xf8, 0x01, 0xf8, 0x00, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 251 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xe0, 0x1f, + 0xf0, 0x1c, 0x38, 0x1c, 0x38, 0x1c, 0x38, 0x1c, 0x38, 0x1c, 0x38, + 0x1c, 0x38, 0x1c, 0x38, 0x1c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 252 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xe0, 0x1f, 0xf0, 0x1c, + 0x70, 0x1c, 0x70, 0x00, 0xe0, 0x01, 0xc0, 0x03, 0x80, 0x07, 0x00, + 0x0e, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 253 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf8, + 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, + 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 254 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 255 */ + +}; diff --git a/kernel/graphics/framebuffer.h b/kernel/graphics/framebuffer.h new file mode 100644 index 0000000..1d6604a --- /dev/null +++ b/kernel/graphics/framebuffer.h @@ -0,0 +1,317 @@ +/*! \file + * \brief \ref Framebuffer implementing primitive graphic operations + */ + +#pragma once + +#include "../types.h" +#include "../utils/string.h" +#include "primitives.h" + +/*! \brief Implementation of primitive operations on a memory area used as + * framebuffer. + * \ingroup gfx + * + * The implementation as template class allows the compiler to heavily optimize + * the bit operations depending on the video mode. + * + * \tparam COLORDEPTH color depth of video mode + * \tparam OFFSET_RED Bit position of red color mask in video mode + * \tparam OFFSET_GREEN Bit position of green color mask in video mode + * \tparam OFFSET_BLUE Bit position of blue color mask in video mode + * \tparam BITS_RED Size of red color mask in video mode + * \tparam BITS_GREEN Size of green color mask in video mode + * \tparam BITS_BLUE Size of blue color mask in video mode + */ +template +class Framebuffer { + /*! \brief Start address of the linear framebuffer + */ + uintptr_t framebuffer; + + /*! \brief Internal width of the screen + * + * At least the visible width of the screen, depends on the hardware but + * required for calculating the rows + */ + unsigned pitch; + + protected: + /*! \brief Visible width of the screen + */ + unsigned screen_width; + + /*! \brief Visible height of the screen + */ + unsigned screen_height; + + /*! \brief Initialize screen dimensions + * + * \param width visible width of graphics screen + * \param height visible height of graphics screen + * \param pitch width of graphics screen (including invisible part, has to + * be at least `width`) + */ + void init(const unsigned width, const unsigned height, + const unsigned pitch) { + this->screen_width = width; + this->screen_height = height; + this->pitch = pitch; + } + + /*! \brief Set the video memory address + * + * \param lfb pointer to the linear framebuffer (lfb) + */ + void buffer(void *lfb) { framebuffer = reinterpret_cast(lfb); } + + /*! \brief Clear all pixel of the current back buffer + * (set full screen to black) + */ + void clear() { + memset(reinterpret_cast(framebuffer), 0, screen_height * pitch); + } + + /*! \brief Pixel component + * + * \tparam OFFSET Bit position of mask + * \tparam BITS Size of mask + */ + template + class PixelComponent { + unsigned : OFFSET; ///< Reserved space for offset + unsigned value : SIZE; ///< Value + + public: + /*! \brief Constructor + * + * \param value Initial component value + */ + explicit PixelComponent(unsigned value) : value(value) {} + + /*! \brief Assign component value + * (from a \ref SpritePixelComponent with different bit mask size) + * + * \tparam BITS Size of bit mask + * \param other new component value + */ + template + void set(const struct SpritePixelComponent &other) { + value = BITS > SIZE ? (other.value >> (BITS - SIZE)) + : (other.value << (SIZE - BITS)); + } + + /*! \brief Assign component value + * (from a \ref SpritePixelComponent with same bit mask size) + * + * \param other new component value + */ + void set(const struct SpritePixelComponent &other) { + value = other.value; + } + + /*! \brief Assign component value + * (from an integer) + * + * \param value new component value + */ + void set(unsigned value) { + value = 8 > SIZE ? (value >> (8 - SIZE)) : (value << (SIZE - 8)); + } + + /*! \brief Alpha blend component value + * (from a \ref SpritePixelComponent with different bit mask size) + * + * \tparam BITS Size of bit mask + * \param other component value to blend + * \param alpha transparency used for blending + */ + template + void blend(const struct SpritePixelComponent &other, + const struct SpritePixelComponent &alpha) { + int other_value = BITS > SIZE ? (other.value >> (BITS - SIZE)) + : (other.value << (SIZE - BITS)); + int other_alpha = BITS > SIZE ? (alpha.value >> (BITS - SIZE)) + : (alpha.value << (SIZE - BITS)); + value += + ((other_value - static_cast(value)) * other_alpha) >> SIZE; + } + + /*! \brief Alpha blend component value + * (from a \ref SpritePixelComponent with same bit mask size) + * + * \param other component value to blend + * \param alpha transparency used for blending + */ + void blend(const struct SpritePixelComponent &other, + const struct SpritePixelComponent &alpha) { + value += + ((static_cast(other.value) - static_cast(value)) * + alpha.value) >> + SIZE; + } + } __attribute__((packed)); + + /*! \brief Pixel (colored) + */ + union Pixel { + /*! \brief Bits per pixel + */ + struct { + unsigned data : COLORDEPTH; ///< RGB value + } __attribute__((packed)); + + PixelComponent red; ///< Red color component + PixelComponent + green; ///< Green color component + PixelComponent blue; ///< Blue color component + + /*! \brief Constructor (using RGB value) + * + * \param data RGB value + */ + explicit Pixel(const unsigned data) : data(data) {} + + /*! \brief Constructor (using explicit RGB components) + * + * Unused bits are zeroed. + * + * \param r Red color component + * \param g Green color component + * \param b Blue color component + */ + Pixel(const unsigned r, const unsigned g, const unsigned b) : data(0) { + red.set(r); + green.set(g); + blue.set(b); + } + + /*! \brief Constructor (using \ref SpritePixel) + * + * \tparam ALPHA `true` if alpha channel + * \tparam BITS Size of mask + * \param other other + */ + template + explicit Pixel(const struct SpritePixel &other) { + red.set(other.red); + green.set(other.green); + blue.set(other.blue); + } + + /*! \brief Get color of pixel + * + * \return color of pixel + */ + Color getColor() const { return Color(red, green, blue); } + + /*! \brief Assign pixel (with colored \ref SpritePixel) + * + * \tparam BITS Size of other pixels mask + * \param other other pixel + */ + template + Pixel &operator=(const struct SpritePixel &other) { + red.set(other.red); + green.set(other.green); + blue.set(other.blue); + return *this; + } + + /*! \brief Assign pixel (with greyscale \ref SpritePixel) + * + * \tparam BITS Size of other pixels mask + * \param other other pixel + */ + template + Pixel &operator=( + const struct SpritePixel &other) { + red.set(other.luminance); + green.set(other.luminance); + blue.set(other.luminance); + return *this; + } + + /*! \brief Assign pixel (with greyscale \ref SpritePixel supporting + * transparency) + * + * \tparam BITS Size of other pixels mask + * \param other other pixel + */ + template + Pixel &operator=(const struct SpritePixel &other) { + red.blend(other.red, other.alpha); + green.blend(other.green, other.alpha); + blue.blend(other.blue, other.alpha); + return *this; + } + + /*! \brief Assign pixel (with greyscale \ref SpritePixel supporting + * transparency) + * + * \tparam BITS Size of other pixels mask + * \param other other pixel + */ + template + Pixel &operator=( + const struct SpritePixel &other) { + red.blend(other.luminance, other.alpha); + green.blend(other.luminance, other.alpha); + blue.blend(other.luminance, other.alpha); + return *this; + } + } __attribute__((packed)); + static_assert(OFFSET_RED + BITS_RED <= COLORDEPTH && + OFFSET_GREEN + BITS_GREEN <= COLORDEPTH && + OFFSET_BLUE + BITS_BLUE <= COLORDEPTH, + "color settings invalid!"); + + /*! \brief Get pixel at position + * + * \param x X position + * \param y Y position + * \return Pointer to pixel + */ + Pixel *get(const unsigned x, const unsigned y) const { + return reinterpret_cast(framebuffer + y * pitch) + x; + } + + /*! \brief Get pixel at position + * + * \param p Coordinate of position + * \return Pointer to pixel + */ + Pixel *get(const Point &p) const { return get(p.x, p.y); } + + /*! \brief Assign color to a pixel at a given position + * + * \tparam COLOR color or greyscale? + * \tparam ALPHA with transparency? + * \tparam BITS Size of mask + * \param x X position + * \param y Y position + * \param color color to assign + */ + template + void set(const unsigned x, const unsigned y, + const SpritePixel &color) { + Pixel *pos = get(x, y); + *pos = color; + } + + /*! \brief Assign color to a pixel at a given position + * + * \tparam COLOR color or greyscale? + * \tparam ALPHA with transparency? + * \tparam BITS Size of mask + * \param p Coordinate of position + * \param color color to assign + */ + template + void set(const Point &p, const SpritePixel &color) { + set(p.x, p.y, color); + } +}; diff --git a/kernel/graphics/primitives.h b/kernel/graphics/primitives.h new file mode 100644 index 0000000..daf8718 --- /dev/null +++ b/kernel/graphics/primitives.h @@ -0,0 +1,168 @@ +/*! \file + * \brief Graphics primitives like \ref Point + */ + +#pragma once + +/*! \brief Coordinate on the graphic screen + * \ingroup gfx + */ +struct Point { + /*! \brief X Position + */ + int x; + + /*! \brief X Position + */ + int y; + + /*! \brief Default Constructor + * + * Initializing the point to the initial position (0, 0) + */ + Point() : x(0), y(0) {} + + /*! \brief Constructor + * + * \brief x X Position + * \brief y Y Position + */ + Point(int x, int y) : x(x), y(y) {} + + /*! \brief Summation of two points + */ + Point operator+(const Point& that) const { + return Point(x + that.x, y + that.y); + } + + /*! \brief Assignment summation of two points + */ + Point& operator+=(const Point& that) { + x += that.x; + y += that.y; + return *this; + } + + /*! \brief Difference of two points + */ + Point operator-(const Point& that) const { + return Point(x - that.x, y - that.y); + } + + /*! \brief Assignment difference of two points + */ + Point& operator-=(const Point& that) { + x -= that.x; + y -= that.y; + return *this; + } +}; + +/*! \brief Color modes + * \ingroup gfx + */ +enum SpriteColorMode { + RGB, ///< Additive color mode (red, green & blue) + GREYSCALE, ///< Greyscale +}; + +/*! \brief Sprite pixel component + * \ingroup gfx + * + * \tparam BITS mask size + */ +template +struct __attribute__((packed)) SpritePixelComponent { + /*! \brief Sprite pixel component value + */ + unsigned int value : BITS; + + /*! \brief Default constructor + * (sets initial value to zero) + */ + SpritePixelComponent() : value(0) {} + + /*! \brief Constructor + * + * \param value Value for component + */ + explicit SpritePixelComponent(unsigned int value) : value(value) {} +}; + +template +struct __attribute__((packed)) SpritePixel; + +/*! \brief Colored pixel with transparency + * \ingroup gfx + * + * \tparam BITS Size of mask + */ +template +struct __attribute__((packed)) SpritePixel { + SpritePixelComponent red; + SpritePixelComponent green; + SpritePixelComponent blue; + SpritePixelComponent alpha; + SpritePixel(unsigned red, unsigned green, unsigned blue, unsigned alpha) + : red(red), green(green), blue(blue), alpha(alpha) {} + SpritePixel() {} +}; + +/*! \brief Colored pixel without transparency + * \ingroup gfx + * + * \tparam BITS Size of mask + */ +template +struct __attribute__((packed)) SpritePixel { + SpritePixelComponent red; + SpritePixelComponent green; + SpritePixelComponent blue; + + SpritePixel(unsigned red, unsigned green, unsigned blue) + : red(red), green(green), blue(blue) {} + SpritePixel() {} +}; + +/*! \brief Greyscale pixel with transparency + * \ingroup gfx + * + * \tparam BITS Size of mask + */ +template +struct __attribute__((packed)) SpritePixel { + SpritePixelComponent luminance; + SpritePixelComponent alpha; + SpritePixel(unsigned luminance, unsigned alpha) + : luminance(luminance), alpha(alpha) {} + SpritePixel() {} +}; + +/*! \brief Greyscale pixel without transparency + * \ingroup gfx + * + * \tparam BITS Size of mask + */ +template +struct __attribute__((packed)) SpritePixel { + SpritePixelComponent luminance; + + explicit SpritePixel(unsigned luminance) : luminance(luminance) {} + SpritePixel() {} +}; + +typedef struct SpritePixel Color; +typedef struct SpritePixel ColorAlpha; + +/*! \brief GIMP image + * \ingroup gfx + * + * Image exported as C-source (without `Glib` types!) in + * [GIMP](https://www.gimp.org/), supports alpha blending (transparency). + */ +struct GIMP { + unsigned int width; + unsigned int height; + unsigned int bytes_per_pixel; + unsigned char pixel_data[]; +}; diff --git a/kernel/graphics/printer.cc b/kernel/graphics/printer.cc new file mode 100644 index 0000000..587987f --- /dev/null +++ b/kernel/graphics/printer.cc @@ -0,0 +1,40 @@ +#include "printer.h" + +#include "../debug/output.h" +#include "../utils/size.h" + +// Predefined video modes (should suit the most common ones) +static GraphicsPrinter<32, 16, 8, 0, 8, 8, 8> default_32bit; +static GraphicsPrinter<24, 16, 8, 0, 8, 8, 8> default_24bit; +static GraphicsPrinter<16, 11, 5, 0, 5, 6, 5> default_16bit; +static GraphicsPrinter<15, 10, 5, 0, 5, 5, 5> default_15bit; +static GraphicsPrinter<8, 5, 2, 0, 3, 3, 2> default_8bit; + +AbstractGraphicsPrinter* supportedGraphicModes[] = { + &default_32bit, &default_24bit, &default_16bit, + &default_15bit, &default_8bit, +}; + +AbstractGraphicsPrinter* AbstractGraphicsPrinter::getMode( + uint8_t colordepth, uint8_t offset_red, uint8_t offset_green, + uint8_t offset_blue, uint8_t bits_red, uint8_t bits_green, + uint8_t bits_blue) { + for (unsigned m = 0; m < ::size(supportedGraphicModes); m++) { + if (supportedGraphicModes[m]->checkMode( + colordepth, offset_red, offset_green, offset_blue, bits_red, + bits_green, bits_blue)) { + return supportedGraphicModes[m]; + } + } + // Show error message (DBG should be copied to serial as well for + // debugging!) + DBG_VERBOSE << "No GraphicsPrinter<" << static_cast(colordepth) << ", " + << static_cast(offset_red) << ", " + << static_cast(offset_green) << ", " + << static_cast(offset_blue) << ", " + << static_cast(bits_red) << ", " + << static_cast(bits_green) << ", " + << static_cast(bits_blue) + << "> instance available - please add!" << endl; + return nullptr; +} diff --git a/kernel/graphics/printer.h b/kernel/graphics/printer.h new file mode 100644 index 0000000..cec4539 --- /dev/null +++ b/kernel/graphics/printer.h @@ -0,0 +1,688 @@ +/*! \file + * \brief \ref GraphicsPrinter and its \ref AbstractGraphicsPrinter + * "abstraction" + */ + +#pragma once + +#include "../utils/math.h" +#include "../utils/png.h" +#include "fonts/font.h" +#include "framebuffer.h" +#include "primitives.h" + +/*! \brief Abstraction of basic graphics printing functions + * \ingroup gfx + * + * The actual implementation is placed in the inherited template class + * \ref GraphicsPrinter for performance reasons. + */ +class AbstractGraphicsPrinter { + protected: + /*! \brief Check if a printer is available for a video mode + * + * This is required since printers are defined during compile time for + * performance reasons. + * + * \tparam colordepth color depth of video mode + * \tparam offset_red Bit position of red color mask in video mode + * \tparam offset_green Bit position of green color mask in video mode + * \tparam offset_blue Bit position of blue color mask in video mode + * \tparam bits_red Size of red color mask in video mode + * \tparam bits_green Size of green color mask in video mode + * \tparam bits_blue Size of blue color mask in video mode + * \return `true` if a printer for the video mode is available + */ + virtual bool checkMode(uint8_t colordepth, uint8_t offset_red, + uint8_t offset_green, uint8_t offset_blue, + uint8_t bits_red, uint8_t bits_green, + uint8_t bits_blue) = 0; + + public: + /*! \brief Initialize printer with actual screen dimensions + * + * \param width visible width of graphics screen + * \param height visible height of graphics screen + * \param pitch width of graphics screen (including invisible part, has to + * be at least `width`) + */ + virtual void init(unsigned width, unsigned height, unsigned pitch) = 0; + + /*! \brief Set the video memory address + * + * \param lfb pointer to the linear framebuffer (lfb) + */ + virtual void buffer(void* lfb) = 0; + + /*! \brief Clear all pixel of the current back buffer + * (set full screen to black) + */ + virtual void clear() = 0; + + /*! \brief Check if a \ref Point can be displayed at the current resolution + * + * \param p Coordinates to check + * \return 'true' if can be displayed + */ + virtual bool valid(const Point& p) const = 0; + + /*! \brief Number of vertical pixels in current resolution + * + * \return Height of the screen in current video mode + */ + virtual unsigned height() const = 0; + + /*! \brief Number of horizontal pixels in current resolution + * + * \return Width of the screen in current video mode + */ + virtual unsigned width() const = 0; + + /*! \brief Draw a pixel + * + * \param p Coordinates of the pixel + * \param color Color of the pixel + */ + virtual void pixel(const Point& p, const Color& color) = 0; + + /// \copydoc AbstractGraphicsPrinter::pixel() + virtual void pixel(const Point& p, const ColorAlpha& color) = 0; + + /*! \brief Draw a line + * + * \param start Coordinates of the begin of the line + * \param end Coordinates of the end of the line + * \param color Color of the line + */ + virtual void line(const Point& start, const Point& end, + const Color& color) = 0; + + /// \copydoc AbstractGraphicsPrinter::line() + virtual void line(const Point& start, const Point& end, + const ColorAlpha& color) = 0; + + /*! \brief Draw a rectangle on the current back buffer + * + * \param start Coordinate of the rectangles upper left corner + * \param end Coordinate of the rectangles lower right corner + * \param color Color of the rectangle + * \param filled If set, the rectangle will be filled with the same color. + * (otherwise only borders will be drawn) + */ + virtual void rectangle(const Point& start, const Point& end, + const Color& color, bool filled = true) = 0; + + /// \copydoc AbstractGraphicsPrinter::rectangle() + virtual void rectangle(const Point& start, const Point& end, + const ColorAlpha& color, bool filled = true) = 0; + + /*! \brief Change the current font for text output in video mode + * + * \param new_font Font to be used on subsequent calls to + * \ref AbstractGraphicsPrinter::text() (without explicit font parameter) + */ + virtual void font(const Font& new_font) = 0; + + /*! \brief Print text (without automatic word wrap). + * + * \param p Upper left start position of the text + * \param string Pointer to char array containing the text to be displayed + * \param len Number of characters to be displayed + * \param color Color for the text characters + * \param font Explicit font -- or `nullptr` to use default font (set by + * \ref font method) + */ + virtual void text(const Point& p, const char* string, unsigned len, + const Color& color, const Font* font = nullptr) = 0; + + /// \copydoc AbstractGraphicsPrinter::text() + virtual void text(const Point& p, const char* string, unsigned len, + const ColorAlpha& color, const Font* font = nullptr) = 0; + + /*! \brief Draw a \ref PNG image (or detail) + * + * The image can has to be in a supported \ref PNG format. + * Alpha blending (transparency) is supported. + * + * \param p Coordinate of the images upper left corner + * \param image Source image to display + * \param width Width of the image detail (full image width of the source + * image if zero/default value) + * \param height Height of the image detail (full image height of the source + * if zero/default value) + * \param offset_x Right offset of the source image + * \param offset_y Top offset of the source image + */ + virtual void image(const Point& p, PNG& image, unsigned width = 0, + unsigned height = 0, unsigned offset_x = 0, + unsigned offset_y = 0) = 0; + + /*! \brief Draw a GIMP image (or detail) + * + * The image has to be exported as C-source (without `Glib` types!) in + * [GIMP](https://www.gimp.org/), alpha blending (transparency) is + * supported. + * + * \param p Coordinate of the images upper left corner + * \param image Source image to display + * \param width Width of the image detail (full image width of the source + * image if zero/default value) + * \param height Height of the image detail (full image height of the source + * if zero/default value) + * \param offset_x Right offset of the source image + * \param offset_y Top offset of the source image + */ + virtual void image(const Point& p, const GIMP& image, unsigned width = 0, + unsigned height = 0, unsigned offset_x = 0, + unsigned offset_y = 0) = 0; + + /*! \brief Draw a sprite. + * + * Each element in the source array will be displayed as a single pixel. + * + * \param p Coordinate of the sprites upper left corner + * \param image Source sprite to display + * \param width Width of the sprite detail + * \param height Height of the sprite detail + * \param offset_x Right offset of the source sprite + * \param offset_y Top offset of the source sprite + */ + virtual void image(const Point& p, const Color* image, unsigned width, + unsigned height, unsigned offset_x = 0, + unsigned offset_y = 0) = 0; + + /*! \brief Draw a sprite with alpha blending (transparency). + * + * Each element in the source array will be displayed as a single pixel. + * + * \param p Coordinate of the sprites upper left corner + * \param image Source sprite to display + * \param width Width of the sprite detail + * \param height Height of the sprite detail + * \param offset_x Right offset of the source sprite + * \param offset_y Top offset of the source sprite + */ + virtual void image(const Point& p, const ColorAlpha* image, unsigned width, + unsigned height, unsigned offset_x = 0, + unsigned offset_y = 0) = 0; + + static AbstractGraphicsPrinter* getMode( + uint8_t colordepth, uint8_t offset_red, uint8_t offset_green, + uint8_t offset_blue, uint8_t bits_red, uint8_t bits_green, + uint8_t bits_blue); +}; + +/*! \brief Actual implementation of basic graphics printing functions + * \ingroup gfx + * + * The implementation as template class requires the definition of the + * desired video mode during compile time (which is required anyways + * since the video mode is set in the \ref Multiboot headers). + * Hence, the compiler is able to optimize the (intensively used) code for the + * actual color bit masks, which results in high performance gain. + * + * \tparam COLORDEPTH color depth of video mode + * \tparam OFFSET_RED Bit position of red color mask in video mode + * \tparam OFFSET_GREEN Bit position of green color mask in video mode + * \tparam OFFSET_BLUE Bit position of blue color mask in video mode + * \tparam BITS_RED Size of red color mask in video mode + * \tparam BITS_GREEN Size of green color mask in video mode + * \tparam BITS_BLUE Size of blue color mask in video mode + */ +template +class GraphicsPrinter + : public Framebuffer, + public AbstractGraphicsPrinter { + typedef Framebuffer + FramebufferBase; + typedef typename FramebufferBase::Pixel Pixel; + + /*! \brief currently active font + */ + Font const* active_font; + + /*! \brief Generic helper function to draw a sprite image (or detail) + * + * \param p Coordinate of the images upper left corner + * \param image Source image to display + * \param width Width of the image detail + * \param height Height of the image detail + * image_width + * \param offset_x Right offset of the source image + * \param offset_y Top offset of the source image + */ + template + void sprite(Point p, + const struct SpritePixel* image, + unsigned width, unsigned height, unsigned image_width, + unsigned offset_x = 0, unsigned offset_y = 0) { + if (p.x < 0) { + offset_x -= p.x; + if (offset_x > width || static_cast(width) + p.x < 0) { + return; + } + width += p.x; + p.x = 0; + } + + if (p.y < 0) { + offset_y -= p.y; + if (offset_y > height || static_cast(height) + p.y < 0) { + return; + } + height += p.y; + p.y = 0; + } + + if (p.x >= static_cast(this->screen_width) || + p.y >= static_cast(this->screen_height)) { + return; + } + + if (p.x + width >= this->screen_width) { + width = this->screen_width - p.x; + } + if (p.y + height >= this->screen_height) { + height = this->screen_height - p.y; + } + + for (unsigned y = offset_y; y < offset_y + height; ++y) { + Pixel* pos = this->get(p); + for (unsigned x = offset_x; x < offset_x + width; ++x) { + *pos = image[y * image_width + x]; + pos++; + } + p.y += 1; + } + } + + /// \copydoc AbstractGraphicsPrinter::pixel() + template + void pixel(const Point& p, const SpritePixel& color) { + if (valid(p)) { + this->set(p, color); + } + } + + /// \copydoc AbstractGraphicsPrinter::line() + template + void line(const Point& start, const Point& end, + const SpritePixel& color) { + const int d_x = Math::abs(end.x - start.x); + const int d_y = Math::abs(end.y - start.y); + const int steps = d_x < d_y ? (d_y + 1) : (d_x + 1); + int D = 2 * (d_x < d_y ? (d_x - d_y) : (d_y - d_x)); + const int DE = d_x < d_y ? (d_x << 1) : (d_y << 1); + const int DNE = (d_x < d_y ? (d_x - d_y) : (d_y - d_x)) << 1; + int x_i1 = d_x < d_y ? 0 : 1; + int x_i2 = 1; + int y_i1 = d_x < d_y ? 1 : 0; + int y_i2 = 1; + if (start.x > end.x) { + x_i1 = -x_i1; + x_i2 = -x_i2; + } + if (start.y > end.y) { + y_i1 = -y_i1; + y_i2 = -y_i2; + } + int x = start.x; + int y = start.y; + for (int i = 0; i < steps; i++) { + if (x >= 0 && y >= 0 && x < static_cast(this->screen_width) && + y < static_cast(this->screen_height)) { + this->set(x, y, color); + } + if (D < 0) { + D += DE; + x += x_i1; + y += y_i1; + } else { + D += DNE; + x += x_i2; + y += y_i2; + } + } + } + + /// \copydoc AbstractGraphicsPrinter::rectangle() + template + void rectangle(const Point& start, const Point& end, + const SpritePixel& color, bool filled) { + const int w = width(); + const int h = height(); + const int fromX = Math::max(0, Math::min(start.x, end.x)); + const int fromY = Math::max(0, Math::min(start.y, end.y)); + const int toX = Math::min(w - 1, Math::max(start.x, end.x)); + const int toY = Math::min(h - 1, Math::max(start.y, end.y)); + if (toX < 0 || toY < 0 || fromX >= w || fromY >= h) { + return; + } + if (filled) { + Point line_start(fromX, fromY); + for (int y = fromY; y < toY; ++y) { + Pixel* pos = this->get(line_start); + for (int x = fromX; x < toX; ++x) { + *pos = color; + pos++; + } + line_start.y++; + } + } else { + line(Point(fromX, fromY), Point(fromX, toY - 1), color); + line(Point(fromX + 1, fromY), Point(toX - 1, fromY), color); + line(Point(fromX, toY), Point(toX - 1, toY), color); + line(Point(toX, fromY), Point(toX, toY), color); + } + } + + /*! \brief Helper function to draw a font pixel image detail + * + * \see \ref text + * + * \param p Coordinate of the images upper left corner + * \param bitmap Font character bitmap source to display + * \param width Width of the font + * \param height Height of the font + * \param color Color for the character + */ + template + void bitmap(const Point& p, const void* bitmap, const unsigned width, + const unsigned height, + const SpritePixel& color) { + unsigned short width_byte = width / 8 + ((width % 8 != 0) ? 1 : 0); + const char* sprite = reinterpret_cast(bitmap); + for (unsigned y = 0; y < height; ++y) { + Pixel* pixel = this->get(p) + y * this->screen_width; + for (unsigned x = 0; x < width_byte; ++x) { + for (int src = 7; src >= 0; --src) { + if ((1 << src) & *sprite) { + *pixel = color; + } + pixel++; + } + sprite++; + } + } + } + + /*! \brief Helper function to print text + * + * \param p Upper left start position of the text + * \param string Pointer to char array containing the text to be displayed + * \param len Number of characters to be displayed + * \param color Color for the text characters + * \param font Explicit font -- or `nullptr` to use default font (set by + * \ref font method) + */ + template + void text(const Point& p, const char* string, unsigned len, + const SpritePixel& color, const Font* font) { + if (font == nullptr) { + font = active_font; + } + if (font != nullptr) { + Point pos = p; + for (unsigned i = 0; i < len; ++i) { + this->bitmap(pos, font->symbol(string[i]), font->width, + font->height, color); + pos.x += font->width; + if (pos.x + font->width > this->screen_width) { + pos.x = 0; + pos.y += font->height; + } + } + } + } + + /*! \brief Check if a \ref Point can be displayed at the current resolution + * + * \param x X position to check + * \param y Y position to check + * \return 'true' if can be displayed + */ + bool valid(const int x, const int y) const { + return x >= 0 && y >= 0 && + static_cast(x) < this->screen_width && + static_cast(y) < this->screen_height; + } + + protected: + /// \copydoc AbstractGraphicsPrinter::checkMode() + bool checkMode(uint8_t required_COLORDEPTH, uint8_t required_red_offset, + uint8_t required_green_offset, uint8_t required_blue_offset, + uint8_t required_red_size, uint8_t required_green_size, + uint8_t required_blue_size) { + return COLORDEPTH == required_COLORDEPTH && + OFFSET_RED == required_red_offset && + OFFSET_GREEN == required_green_offset && + OFFSET_BLUE == required_blue_offset && + BITS_RED == required_red_size && + BITS_GREEN == required_green_size && + BITS_BLUE == required_blue_size; + } + + public: + /*! \brief Constructor + */ + GraphicsPrinter() {} + + /// \copydoc AbstractGraphicsPrinter::init() + void init(unsigned width, unsigned height, unsigned pitch) { + FramebufferBase::init(width, height, pitch); + active_font = Font::get("Sun", 12, 22); + } + + /// \copydoc AbstractGraphicsPrinter::buffer() + void buffer(void* lfb) { FramebufferBase::buffer(lfb); } + + /// \copydoc AbstractGraphicsPrinter::clear() + void clear() { FramebufferBase::clear(); } + + /// \copydoc AbstractGraphicsPrinter::valid() + bool valid(const Point& p) const { return valid(p.x, p.y); } + + /// \copydoc AbstractGraphicsPrinter::height() + unsigned height() const { return this->screen_height; } + + /// \copydoc AbstractGraphicsPrinter::width() + unsigned width() const { return this->screen_width; } + + /// \copydoc AbstractGraphicsPrinter::pixel() + void pixel(const Point& p, const Color& color) { + return pixel(p, color); + } + + /// \copydoc AbstractGraphicsPrinter::pixel() + void pixel(const Point& p, const ColorAlpha& color) { + return pixel(p, color); + } + + /// \copydoc AbstractGraphicsPrinter::line() + void line(const Point& start, const Point& end, const Color& color) { + return line(start, end, color); + } + + /// \copydoc AbstractGraphicsPrinter::line() + void line(const Point& start, const Point& end, const ColorAlpha& color) { + return line(start, end, color); + } + + /// \copydoc AbstractGraphicsPrinter::rectangle() + void rectangle(const Point& start, const Point& end, const Color& color, + bool filled) { + return rectangle(start, end, color, filled); + } + + /// \copydoc AbstractGraphicsPrinter::rectangle() + void rectangle(const Point& start, const Point& end, + const ColorAlpha& color, bool filled) { + return rectangle(start, end, color, filled); + } + + /// \copydoc AbstractGraphicsPrinter::font() + void font(const Font& new_font) { active_font = &new_font; } + + /// \copydoc AbstractGraphicsPrinter::text() + void text(const Point& p, const char* string, unsigned len, + const Color& color, const Font* font) { + return text(p, string, len, color, font); + } + + /// \copydoc AbstractGraphicsPrinter::text() + void text(const Point& p, const char* string, unsigned len, + const ColorAlpha& color, const Font* font) { + return text(p, string, len, color, font); + } + + /// \copydoc AbstractGraphicsPrinter::image(const + /// Point&,PNG&,unsigned,unsigned,unsigned,unsigned) + void image(const Point& p, PNG& image, unsigned width = 0, + unsigned height = 0, unsigned offset_x = 0, + unsigned offset_y = 0) { + unsigned w = image.get_width(); + unsigned h = image.get_height(); + if (width == 0 || offset_x + width > w) { + if (offset_x > w) { + return; + } else { + width = w - offset_x; + } + } + if (height == 0 || offset_y + height > h) { + if (offset_y > h) { + return; + } else { + height = h - offset_y; + } + } + + switch (image.get_format()) { + case PNG::RGB8: + sprite( + p, + reinterpret_cast*>( + image.get_buffer()), + width, height, w, offset_x, offset_y); + break; + case PNG::RGB16: + sprite( + p, + reinterpret_cast*>( + image.get_buffer()), + width, height, w, offset_x, offset_y); + break; + case PNG::RGBA8: + sprite( + p, + reinterpret_cast*>( + image.get_buffer()), + width, height, w, offset_x, offset_y); + break; + case PNG::RGBA16: + sprite( + p, + reinterpret_cast*>( + image.get_buffer()), + width, height, w, offset_x, offset_y); + break; + case PNG::LUMINANCE8: + sprite( + p, + reinterpret_cast< + const struct SpritePixel*>( + image.get_buffer()), + width, height, w, offset_x, offset_y); + break; + case PNG::LUMINANCE_ALPHA4: + sprite( + p, + reinterpret_cast< + const struct SpritePixel*>( + image.get_buffer()), + width, height, w, offset_x, offset_y); + break; + case PNG::LUMINANCE_ALPHA8: + sprite( + p, + reinterpret_cast< + const struct SpritePixel*>( + image.get_buffer()), + width, height, w, offset_x, offset_y); + break; + default: + // "Unsupported PNG format"; + break; + } + } + + /// \copydoc AbstractGraphicsPrinter::image(const Point&,const + /// GIMP&,unsigned,unsigned,unsigned,unsigned) + void image(const Point& p, const GIMP& image, unsigned width = 0, + unsigned height = 0, unsigned offset_x = 0, + unsigned offset_y = 0) { + unsigned w = image.width; + unsigned h = image.height; + if (width == 0 || offset_x + width > w) { + if (offset_x > w) { + return; + } else { + width = w - offset_x; + } + } + if (height == 0 || offset_y + height > h) { + if (offset_y > h) { + return; + } else { + height = h - offset_y; + } + } + + switch (image.bytes_per_pixel) { + case 2: // RGB16 + sprite( + p, + reinterpret_cast*>( + image.pixel_data), + width, height, w, offset_x, offset_y); + break; + case 3: // RGB + sprite( + p, + reinterpret_cast*>( + image.pixel_data), + width, height, w, offset_x, offset_y); + break; + case 4: // RGBA + sprite( + p, + reinterpret_cast*>( + image.pixel_data), + width, height, w, offset_x, offset_y); + break; + default: + // "Unsupported PNG format"; + break; + } + } + + /// \copydoc AbstractGraphicsPrinter::image(const Point&,const + /// Color*,unsigned,unsigned,unsigned,unsigned) + void image(const Point& p, const Color* image, unsigned width, + unsigned height, unsigned offset_x = 0, unsigned offset_y = 0) { + sprite(p, image, width, height, width, offset_x, + offset_y); + } + + /// \copydoc AbstractGraphicsPrinter::image(const Point&,const + /// ColorAlpha*,unsigned,unsigned,unsigned,unsigned) + void image(const Point& p, const ColorAlpha* image, unsigned width, + unsigned height, unsigned offset_x = 0, unsigned offset_y = 0) { + sprite(p, image, width, height, width, offset_x, + offset_y); + } +}; diff --git a/kernel/interrupt/epilogues.cc b/kernel/interrupt/epilogues.cc new file mode 100644 index 0000000..21dd0f1 --- /dev/null +++ b/kernel/interrupt/epilogues.cc @@ -0,0 +1,20 @@ +#include "epilogues.h" + +#include "../thread/thread.h" +#include "guard.h" + +Key Epilogues::key; + +void Epilogues::keyboard(Vault& v) { + if (v.keys.produce(key)) { + v.keys_sem.v(v); + } + key.invalidate(); +} + +void Epilogues::timer(Vault& v) { + // Let Bellringer check for waiting threads + v.bellringer.check(v); + // Reschedule on each tick + v.scheduler.resume(); +} diff --git a/kernel/interrupt/epilogues.h b/kernel/interrupt/epilogues.h new file mode 100644 index 0000000..dc33f1c --- /dev/null +++ b/kernel/interrupt/epilogues.h @@ -0,0 +1,42 @@ +/*! \file + * \brief Abstraction for epilogue objects, basically function pointers. + * \ingroup interrupts + */ +#pragma once +#include "../object/key.h" +#include "../types.h" + +struct Vault; + +/*! \brief A handler function for an epilogue. + * \ingroup interrupts + * + * It receives the vault directly, because it is executed on level 1/2 (by the + * \ref Guard) . + * + * \note Since it does only receive one parameter, other data must be passed + * in a different way. + */ +using Epilogue = void (*)(Vault&); + +namespace Epilogues { + +/*! + * @brief The keyboard epilogue. + * + * Handle the keyboard Key that has been fetched during the prologue. + * + * threads waiting for a key using the key semaphore. + * + * @param v The vault. + */ +void keyboard(Vault& v); +extern Key key; + +/*! + * @brief Timer epilogue + * @param v The vault. + */ +void timer(Vault& v); + +}; // namespace Epilogues diff --git a/kernel/interrupt/guard.cc b/kernel/interrupt/guard.cc new file mode 100644 index 0000000..0b92480 --- /dev/null +++ b/kernel/interrupt/guard.cc @@ -0,0 +1,114 @@ +/*! \file + * \brief Guard implementation + */ + +#include "guard.h" + +#include "../arch/cache.h" +#include "../arch/core.h" +#include "../debug/assert.h" // IWYU pragma: keep +#include "../debug/output.h" +#include "../object/bbuffer.h" +#include "epilogues.h" + +//! \brief The protected data for the epilogue level +static Vault global_vault; + +//! \brief State of the epilogue level (per core) +struct State { + //! \brief lists of pending epilogues + BBuffer epilogue_queue; + //! \brief indicates whether the epilogue level is entered + bool epi_flag = false; +} __attribute__((aligned(CACHE_LINE_SIZE))); + +constinit State state = {}; + +static inline State &get_state() { return state; } + +Vault::Vault() {} + +Guarded::~Guarded() { Guard::leave(); } + +Guarded Guard::enter() { + assert(!get_state().epi_flag); + + // Mark entry of epilogue level on this core + get_state().epi_flag = true; + + return Guarded(global_vault); +} + +void Guard::leave() { + // Make sure that we've performed an enter before. + assert(get_state().epi_flag); + + Vault &vault = global_vault; + + bool status; + while (true) { + status = Core::Interrupt::disable(); + + // Get item from epilogue queue (if any) + Epilogue iter; + if (!get_state().epilogue_queue.consume(iter)) { + break; + } + + // Interrupts shall be restored before processing the epilogue + Core::Interrupt::restore(status); + + // Process epilogue + iter(vault); + } + + // leave the epilogue level this core + get_state().epi_flag = false; + + // Restore previous interrupt state + Core::Interrupt::restore(status); +} + +void Guard::relay(Epilogue handler) { + if (get_state().epi_flag) { + // Enqueue epilogue + bool success = get_state().epilogue_queue.produce(handler); + if (!success) DBG << "Dropped epilogue!" << endl; + } else { + // Mark entry of epilogue level on this core + get_state().epi_flag = true; + + // Enable interrupts (interrupt_handler should already have sent the ACK + // IRQ via LAPIC) + Core::Interrupt::enable(); + + // We are, at this point, in the prologue level (E1), so this is + // allowed: + Vault &vault = global_vault; + + // Process epilogue + handler(vault); + + // Make sure pending epilogues are executed + while (true) { + // Disable Interrupts while accessing the epilogue queue + Core::Interrupt::disable(); + Epilogue iter; + if (!get_state().epilogue_queue.consume(iter)) { + break; + } + + // Interrupts shall be enabled before processing the epilogue + Core::Interrupt::enable(); + + // Process epilogue + iter(vault); + } + Core::Interrupt::disable(); + + // leave the epilogue level this core + get_state().epi_flag = false; + } +} + +const Vault &Guard::unsafeConstAccess() { return global_vault; } diff --git a/kernel/interrupt/guard.h b/kernel/interrupt/guard.h new file mode 100644 index 0000000..16c20fc --- /dev/null +++ b/kernel/interrupt/guard.h @@ -0,0 +1,132 @@ +/*! \file + * \brief Guard synchronizes access to epilogue level + */ + +#pragma once +#include "../device/graphics.h" +#include "../device/textstream.h" +#include "../object/bbuffer.h" +#include "../object/key.h" +#include "../sync/bellringer.h" +#include "../sync/semaphore.h" +#include "../thread/scheduler.h" +#include "../types.h" +#include "./epilogues.h" + +//! \brief The epilogue vault contains the protected data for the epilogue level +struct Vault { + TextStream kout = TextStream(0, 80, 0, 17, true); + Scheduler scheduler; + Bellringer bellringer; + BBuffer keys; + Semaphore keys_sem; + + // Ignore this for now, this is for a bonus task + Graphics graphics; + + Vault(); + // no copy + Vault(const Vault&) = delete; + Vault& operator=(const Vault&) = delete; +}; + +/*! \brief Lock guard that provides access to the epilogue \ref Vault + * + * This object automatically unlocks the \ref Guard when it goes out of scope. + */ +class Guarded { + public: + //! This constructor should only be used by the \ref Guard + explicit Guarded(Vault& vault) : _vault(vault) {} + //! Leave the critical section + ~Guarded(); + + //! Access the epilogue vault + Vault& vault() { return _vault; } + const Vault& vault() const { return _vault; } + + // no copy + Guarded(const Guarded&) = delete; + Guarded& operator=(const Guarded&) = delete; + + private: + Vault& _vault; +}; + +/*! \brief Synchronizes the kernel with interrupts using the Prologue/Epilogue + * Model \ingroup interrupts + * + * The Guard is used to synchronize between "normal" core activities (currently + * just the text output, later system calls) and interrupt handling routines. + * For this purpose, \ref Guard has to contain one ore more \ref BBuffer + * "queues", in which \ref Epilogue functions can be added. This is necessary if + * the critical section is occupied at the time when an interrupt occurs, and + * the + * \ref Epilogue cannot be executed immediately. The queued epilogues are + * processed when leaving the critical section. + * + * **Hints:** + * - The epilogue queue is a central data structure, whose consistency + * must be ensured. The implementation provided by the \ref BBuffer is not + * entirely safe against concurrency. You need to disable + * interrupts during operations on the buffer. + * - In \MPStuBS, you need a separate epilogue queue for each core, + * in which each processor serializes *its* epilogues. However, epilogues + * on different cores could then be executed in parallel, since the + * critical section is managed separately on a per-core base. This must be + * prevented by using a global \ref Ticketlock to avoid concurrent + * execution of epilogues -- there must never be more than one epilogue + * active on the whole system at the same time!
+ * *Please note:* This [giant lock](https://en.wikipedia.org/wiki/Giant_lock) + * (synchronizing all cores) should not be confused with the (core-specific) + * flag variable that marks only the entry to the epilogue level on the + * corresponding core! + * - Interrupts should be disabled for as short as possible. Due to this + * reason, the prologue/epilogue model allows epilogues to be interrupted + * by prologues. This means that interrupts should be + * \ref Core::Interrupt::enable "enabled" again before the epilogue is + * executed (this includes notifying the APIC about the + * \ref LAPIC::endOfInterrupt() "End-Of-Interrupt") + */ +namespace Guard { + +/*! \brief Entering the critical section from level 0. + * + * Entering the critical section has to be handled differently depending on + * the system: In a single-core system it is sufficient to mark the entry + * by just setting a flag variable (since only one control flow can enter + * the critical section at the same time). However, as soon as there are + * multiple cores, this is no longer the case. If a core wants to enter the + * critical section while *another* core is already in there, it should + * (actively) wait in this method until the critical area is released again. + * + */ +Guarded enter(); + +/*! \brief Leaving the critical section. + * + * Leaves the critical section and processes all remaining (enqueued) epilogues. + * This may only be called while in level 1/2 after calling \ref enter(). + * + * Note: Usually, this method is called by the destructor of the \ref + * Guarded. + * + */ +void leave(); + +/*! \brief A prologue wants its epilogue to be processed (entering from level + * 1). + * + * This method is called by the interrupt handlers. + * Whether the passed epilogue is executed immediately or it just enqueued to + * the epilogue queue depends on whether the critical section on *this* Core is + * accessible or not. + * + */ +void relay(Epilogue handler); + +/*! \brief Access the epilogue vault without taking the lock. + * Beware race conditions! + */ +const Vault& unsafeConstAccess(); +} // namespace Guard diff --git a/kernel/interrupt/handlers.asm b/kernel/interrupt/handlers.asm new file mode 100644 index 0000000..5edd108 --- /dev/null +++ b/kernel/interrupt/handlers.asm @@ -0,0 +1,39 @@ +[SECTION .text] +[EXTERN handle_keyboard] +[GLOBAL handle_keyboard_asm] + +; entry point for an interrupt to trigger a kernelpanic +; +align 16 +handle_keyboard_asm: + ; The interrupt may be triggered asynchronously, therefore the whole context + ; has to be saved and restored, or the interrupted code might not be able to + ; continue. The C++ compiler will only generates code to preserve + ; non-scratch registers in the high-level interrupt handler -- the scratch + ; registers have to be saved (and restored later) manually! + push rax + push rcx + push rdx + push rsi + push rdi + push r8 + push r9 + push r10 + push r11 + + ; Clear direction flag for string operations + cld + ; Call the high-level handler routine + call handle_keyboard + + ; Restore scratch registers + pop r11 + pop r10 + pop r9 + pop r8 + pop rdi + pop rsi + pop rdx + pop rcx + pop rax + iretq diff --git a/kernel/interrupt/handlers.cc b/kernel/interrupt/handlers.cc new file mode 100644 index 0000000..a277a6d --- /dev/null +++ b/kernel/interrupt/handlers.cc @@ -0,0 +1,134 @@ +#include "./handlers.h" + +#include "../arch/core_cr.h" +#include "../arch/idt.h" +#include "../arch/lapic.h" +#include "../arch/system.h" +#include "../debug/kernelpanic.h" +#include "../debug/output.h" +#include "../device/ps2controller.h" +#include "./epilogues.h" +#include "./guard.h" + +static void printContext(const InterruptContext *context) { + DBG << "ip: " << hex << context->cs << ':' << context->ip + << " sp: " << context->ss << ':' << context->sp << " flags" << bin + << context->flags << endl; +} + +[[gnu::interrupt]] static void handle_invalid_opcode( + InterruptContext *context) { + DBG << "Invalid opcode encountered" << endl; + printContext(context); + kernelpanic("Invalid opcode!"); +} + +[[gnu::interrupt]] static void handle_double_fault(InterruptContext *context, + uint64_t error) { + DBG << "Double fault encountered. Error code: " << dec << error << endl; + printContext(context); + kernelpanic("Double fault!"); +} + +[[gnu::interrupt]] static void handle_invalid_tss(InterruptContext *context, + uint64_t error) { + DBG << "Invalid tss encountered. Offending selector idx: " << dec << error + << endl; + printContext(context); + kernelpanic("Invalid TSS!"); +} + +[[gnu::interrupt]] static void handle_general_protection_fault( + InterruptContext *context, uint64_t error) { + DBG << "General protection fault encountered. Error code: " << dec << error + << endl; + printContext(context); + kernelpanic("General protection fault!"); +} + +[[gnu::interrupt]] static void handle_page_fault(InterruptContext *context, + uint64_t error) { + DBG << "Page fault encountered at linear address " << hex + << Core::CR<2>::read() << endl + << PageFaultError(error) << endl; + printContext(context); + kernelpanic("Page fault!"); +} + +/*! \brief Assembly interrupt handler for the keyboard. + * + * On keyboard interrupt, the register state is saved to and restored from the + * stack. This function wraps the handle_keyboard C-function. + * + */ +extern "C" [[gnu::interrupt]] void handle_keyboard_asm( + InterruptContext *context); + +/*! \brief Higher-level Interrupt handler for the keyboard. + * + * On keyboard interrupt, the PS2-Controller may contain a valid Key that has to + * be fetched. + * + */ +extern "C" void handle_keyboard() { + // DBG_VERBOSE << "Keyboard interrupt" << endl; + Key key; + if (PS2Controller::fetch(key)) { + // Ctrl-Alt-Delete should perform a reboot. This should still be done in + // prologue, to ensure that rebooting still works reliably in case of + // broken epilogues. + if (key.ctrl() && key.alt() && key.scancode == Key::Scancode::KEY_DEL) { + System::reboot(); + } + + // Check if the last key was processed by the epilogue + if (!Epilogues::key.valid()) { + // Make sure we can receive new interrupts + LAPIC::endOfInterrupt(); + // Enqueue new epilogue + Epilogues::key = key; + Guard::relay(Epilogues::keyboard); + return; + } + } + LAPIC::endOfInterrupt(); +} + +[[maybe_unused, gnu::interrupt]] static void handle_panic( + InterruptContext *context) { + (void)context; + kernelpanic("Panic interrupt triggered!"); +} + +[[maybe_unused, gnu::interrupt]] static void handle_timer( + InterruptContext *context) { + // DBG_VERBOSE << "Timer interrupt" << endl; + (void)context; + LAPIC::endOfInterrupt(); + Guard::relay(Epilogues::timer); +} + +void initInterruptHandlers() { + // Some handlers that are useful for debugging + IDT::set(Core::Interrupt::Vector::INVALID_OPCODE, + IDT::InterruptDescriptor::Returning(handle_invalid_opcode)); + IDT::set(Core::Interrupt::Vector::DOUBLE_FAULT, + IDT::InterruptDescriptor::DivergingWithError(handle_double_fault)); + IDT::set(Core::Interrupt::Vector::INVALID_TSS, + IDT::InterruptDescriptor::ReturningWithError(handle_invalid_tss)); + IDT::set(Core::Interrupt::Vector::GENERAL_PROTECTION_FAULT, + IDT::InterruptDescriptor::ReturningWithError( + handle_general_protection_fault)); + IDT::set(Core::Interrupt::Vector::PAGE_FAULT, + IDT::InterruptDescriptor::ReturningWithError(handle_page_fault)); + + // TODO: Add more handlers here + IDT::set(Core::Interrupt::Vector::KEYBOARD, + IDT::InterruptDescriptor::Returning(handle_keyboard_asm)); + IDT::set(Core::Interrupt::Vector::PANIC, + IDT::InterruptDescriptor::Returning(handle_panic)); + IDT::set(Core::Interrupt::Vector::TIMER, + IDT::InterruptDescriptor::Returning(handle_timer)); + // Load the idt pointer + IDT::load(); +} diff --git a/kernel/interrupt/handlers.h b/kernel/interrupt/handlers.h new file mode 100644 index 0000000..e90364e --- /dev/null +++ b/kernel/interrupt/handlers.h @@ -0,0 +1,19 @@ +/*! \file + * \brief All interrupts need to start somewhere. This file contains the entry + * points for all interrupts handled by StuBS. + * \defgroup interrupts Interrupt Handling + */ +#pragma once +#include "../types.h" + +/*! \brief Initialize the IDT. + * + * The interrupt subsystem of StubBS contains all functionality to accept + * interrupts from the hardware and process them. + * In later exercises the interrupts will enable applications to + * execute core functionality (system calls). + * The entry point for the interrupt subsystem is the function + * 'interrupt_entry_VECTOR' (in `interrupt/handler.asm`). + * + */ +void initInterruptHandlers(); diff --git a/kernel/main.cc b/kernel/main.cc new file mode 100644 index 0000000..03b036c --- /dev/null +++ b/kernel/main.cc @@ -0,0 +1,79 @@ + +#include "./arch/lapic.h" +#include "./debug/copystream.h" +#include "./debug/output.h" +#include "./device/serialstream.h" +#include "./types.h" // This is actually used +#include "arch/core_interrupt.h" +SerialStream sout; + +#include "./device/textstream.h" + +// Separate title window on first line (for simplicity at scrolling) +static TextStream tout(0, CGA::COLUMNS, 0, 1); + +TextStream dout(0, 80, 17, 25); +CopyStream copystream(&dout, &sout); +OutputStream* copyout = ©stream; + +#include "./arch/core.h" +#include "./arch/ioapic.h" +#include "./device/ps2controller.h" +#include "./interrupt/guard.h" +#include "./sync/semaphore.h" +#include "./thread/thread.h" +Semaphore koutsem(1); +TextStream kout(0, 80, 1, 17, true); + +// Applications +#include "./user/app1/appl.h" +#include "./user/app2/kappl.h" + +static const uint32_t NUM_APPS = 9; +Application apps[NUM_APPS]; + +static KeyboardApplication kapp; + +// Main function +extern "C" int main() { + tout.reset(); + tout.setPos(33, 0); + tout << OS_NAME << " (2.x)" << flush; + + // Initialize IOAPIC + IOAPIC::init(); + + // Init timer (1000us = 1ms) + LAPIC::Timer::setup(10000); + + // Activate Keyboard + PS2Controller::init(); + + // Enter Level 1/2 + Guarded g = Guard::enter(); + + for (uint32_t i = 0; i < NUM_APPS; ++i) { + g.vault().scheduler.ready(&(apps[i])); + } + + g.vault().scheduler.ready(&kapp); + + // Enable Interrupts + Core::Interrupt::enable(); + + /* Activate timer + * Be careful: + * If enabled early and interrupts are enabled, it might start scheduling + * (resume in epilogue) and dispatch the first app, never returning back to + * main and finish initialization. + * Therefore activate the LAPIC timer in level 1/2 after initialization + * (just before schedule()) + */ + LAPIC::Timer::activate(); + + DBG_VERBOSE << "Schedule..." << endl; + // Schedule first app + g.vault().scheduler.schedule(); + + return 0; +} diff --git a/kernel/memory/config.h b/kernel/memory/config.h new file mode 100644 index 0000000..d29e575 --- /dev/null +++ b/kernel/memory/config.h @@ -0,0 +1,20 @@ +#pragma once +#include "../types.h" + +// External symbols introduced by the linker with kernel start and end address +extern "C" void* ___KERNEL_START___; +extern "C" void* ___KERNEL_END___; + +/*! \brief Lowest memory address we will make use of + * It seems wise to ignore everything below the first 1 MB + * since it is used by BIOS and memory mapped devices, + * and not every BIOS gives us a correct memory map. + */ +const uintptr_t KERNEL_SPACE = 0x100000; + +/*! \brief Border between Kernel and User space + * Memory below this border (starting by MINIMUM) is for kernel (which is + * identity mapped), memory above for user space. + * Let's choose 64 MB since this should be enough for the kernel. + */ +const uintptr_t USER_SPACE = 0x4000000; diff --git a/kernel/memory/page.h b/kernel/memory/page.h new file mode 100644 index 0000000..121083a --- /dev/null +++ b/kernel/memory/page.h @@ -0,0 +1,55 @@ +#pragma once +#include "../types.h" + +namespace Page { +/*! \brief Page Bits + * We use the least significant 12 Bits + */ +const uintptr_t BITS = 12; + +/*! \brief Page size + * We go with 2^12 = 4K + */ +const uintptr_t SIZE = 1 << BITS; + +/*! \brief Mask for Page + */ +const uintptr_t MASK = SIZE - 1; + +/*! \brief Round to next (upper) page aligned address + * \param address memory address + * \return nearest ceiling page aligned address + */ +template +T ceil(T address) { + return (address + MASK) & (~MASK); +} + +/*! \brief Round to last (lower) page aligned address + * \param address memory address + * \return nearest floor page aligned address + */ +template +T floor(T ptr) { + return ptr & (~MASK); +} + +/*! \brief Get offset in page + * \param address memory address + * \return offset + */ +template +T offset(T ptr) { + return ptr & MASK; +} + +/*! \brief Check if address is page aligned + * \param address memory address + * \return true if page aligned address + */ +template +bool aligned(T ptr) { + return offset(ptr) == 0; +} + +} // namespace Page diff --git a/kernel/memory/pagefault.cc b/kernel/memory/pagefault.cc new file mode 100644 index 0000000..752bf01 --- /dev/null +++ b/kernel/memory/pagefault.cc @@ -0,0 +1,49 @@ + +#include "memory/pagefault.h" + +#include "arch/core.h" +#include "arch/core_interrupt.h" +#include "arch/idt.h" +#include "debug/output.h" +#include "memory/config.h" + +namespace PageFault { + +union ErrorCode { + uint32_t value; + struct { + uint32_t present : 1; ///< was the page present? + uint32_t write : 1; ///< was the access a write? + uint32_t usermode : 1; ///< was it in user mode? + uint32_t reserved : 1; ///< reserved bit violation + uint32_t instruction : 1; ///< was it caused by instruction fetch? + uint32_t : 0; + } __attribute__((packed)); + + explicit ErrorCode(uint32_t value) : value(value) {} +}; + +assert_size(ErrorCode, 4); + +[[gnu::interrupt]] static void pagefault_handler(InterruptContext *context, + uint64_t err) { + PageFault::ErrorCode error(err); + // Get the faulting address + uintptr_t virt; + asm volatile("mov %%cr2, %0" : "=r"(virt)); + DBG << "Page fault at " << hex << virt << dec << endl; + + // show page fault message + DBG << "PAGEFAULT: " << hex << virt << ":" << dec << error.present + << error.write << error.usermode << error.reserved << error.instruction + << " @ " << hex << context->ip << endl; + + Core::die(); +} + +void init() { + IDT::set(Core::Interrupt::Vector::PAGE_FAULT, + IDT::InterruptDescriptor::ReturningWithError(pagefault_handler)); +} + +} // namespace PageFault diff --git a/kernel/memory/pagefault.h b/kernel/memory/pagefault.h new file mode 100644 index 0000000..051a69c --- /dev/null +++ b/kernel/memory/pagefault.h @@ -0,0 +1,12 @@ +#pragma once +#include "../debug/assert.h" +#include "../interrupt/handlers.h" +#include "../types.h" + +/*! \brief Page Fault Handler + */ +namespace PageFault { +/*! \brief Install page fault handler + */ +void init(); +} // namespace PageFault diff --git a/kernel/object/bbuffer.h b/kernel/object/bbuffer.h new file mode 100644 index 0000000..425a0f4 --- /dev/null +++ b/kernel/object/bbuffer.h @@ -0,0 +1,62 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief Contains a \ref BBuffer "bounded buffer" + */ + +#pragma once +#include "../types.h" + +/*! \brief The class BBuffer implements a bounded buffer, that is a circular + * buffer with a fixed capacity. + * + * \tparam T the type of data to be stored + * \tparam CAP the buffers capacity (must be greater than 1) + */ +template +class BBuffer { + static_assert(CAP > 1, "BBuffer of size 1 is unsupported."); + // Prevent copies and assignments + BBuffer(const BBuffer&) = delete; + BBuffer& operator=(const BBuffer&) = delete; + + private: + T data[CAP] = {}; + volatile unsigned in = 0; + volatile unsigned out = 0; + + public: + /*! \brief Constructor that initialized an empty buffer. + */ + constexpr BBuffer() {} + + /*! \brief Add an element to the buffer. + * \param val The element to be added. + * \return `false` if the buffer is full and no element can be added; + * `true` otherwise. + */ + bool produce(T val) { + unsigned nextin = (in + 1) % CAP; + if (nextin != out) { + data[in] = val; + in = nextin; + return true; + } + return false; + } + + /*! \brief Remove an element from the buffer. + * \param val Output parameter that receives the next element. If there is + * (currently) no next element, `val` will not be modified. + * \return `false` if the buffer was empty; `true` if the buffer was + * not empty and an element was written to val. + */ + bool consume(T& val) { + if (in != out) { + val = data[out]; + out = (out + 1) % CAP; + return true; + } + return false; + } +}; diff --git a/kernel/object/key.cc b/kernel/object/key.cc new file mode 100644 index 0000000..cfb8fbb --- /dev/null +++ b/kernel/object/key.cc @@ -0,0 +1,121 @@ +#include "key.h" + +// Character table for scan codes for US keyboards +static const struct { + unsigned char normal; // Character without modifiers + unsigned char shift; // With pressed Shift, Capslock, or in Numpad + unsigned char alt; // With pressed Alt key +} ascii_tab[static_cast(Key::Scancode::KEYS)] = { + {0, 0, 0}, // KEY_INVALID + {0, 0, 0}, // KEY_ESCAPE + {'1', '!', 0}, // KEY_1 + {'2', '"', 253}, // KEY_2 + {'3', 21, 0}, // KEY_3 + {'4', '$', 0}, // KEY_4 + {'5', '%', 0}, // KEY_5 + {'6', '&', 0}, // KEY_6 + {'7', '/', '{'}, // KEY_7 + {'8', '(', '['}, // KEY_8 + {'9', ')', ']'}, // KEY_9 + {'0', '=', '}'}, // KEY_0 + {225, '?', '\\'}, // KEY_DASH + {39, 96, 0}, // KEY_EQUAL + {'\b', 0, 0}, // KEY_BACKSPACE + {0, 0, 0}, // KEY_TAB + {'q', 'Q', '@'}, // KEY_Q + {'w', 'W', 0}, // KEY_W + {'e', 'E', 0}, // KEY_E + {'r', 'R', 0}, // KEY_R + {'t', 'T', 0}, // KEY_T + {'z', 'Z', 0}, // KEY_Y + {'u', 'U', 0}, // KEY_U + {'i', 'I', 0}, // KEY_I + {'o', 'O', 0}, // KEY_O + {'p', 'P', 0}, // KEY_P + {129, 154, 0}, // KEY_OPEN_BRACKET + {'+', '*', '~'}, // KEY_CLOSE_BRACKET + {'\n', 0, 0}, // KEY_ENTER + {0, 0, 0}, // KEY_LEFT_CTRL + {'a', 'A', 0}, // KEY_A + {'s', 'S', 0}, // KEY_S + {'d', 'D', 0}, // KEY_D + {'f', 'F', 0}, // KEY_F + {'g', 'G', 0}, // KEY_G + {'h', 'H', 0}, // KEY_H + {'j', 'J', 0}, // KEY_J + {'k', 'K', 0}, // KEY_K + {'l', 'L', 0}, // KEY_L + {148, 153, 0}, // KEY_SEMICOLON + {132, 142, 0}, // KEY_APOSTROPH + {'^', 248, 0}, // KEY_GRAVE_ACCENT + {0, 0, 0}, // KEY_LEFT_SHIFT + {'#', 39, 0}, // KEY_BACKSLASH + {'y', 'Y', 0}, // KEY_Z + {'x', 'X', 0}, // KEY_X + {'c', 'C', 0}, // KEY_C + {'v', 'V', 0}, // KEY_V + {'b', 'B', 0}, // KEY_B + {'n', 'N', 0}, // KEY_N + {'m', 'M', 230}, // KEY_M + {',', ';', 0}, // KEY_COMMA + {'.', ':', 0}, // KEY_PERIOD + {'-', '_', 0}, // KEY_SLASH + {0, 0, 0}, // KEY_RIGHT_SHIFT + {'*', '*', 0}, // KEY_KP_STAR + {0, 0, 0}, // KEY_LEFT_ALT + {' ', ' ', 0}, // KEY_SPACEBAR + {0, 0, 0}, // KEY_CAPS_LOCK + {0, 0, 0}, // KEY_F1 + {0, 0, 0}, // KEY_F2 + {0, 0, 0}, // KEY_F3 + {0, 0, 0}, // KEY_F4 + {0, 0, 0}, // KEY_F5 + {0, 0, 0}, // KEY_F6 + {0, 0, 0}, // KEY_F7 + {0, 0, 0}, // KEY_F8 + {0, 0, 0}, // KEY_F9 + {0, 0, 0}, // KEY_F10 + {0, 0, 0}, // KEY_NUM_LOCK + {0, 0, 0}, // KEY_SCROLL_LOCK + {0, '7', 0}, // KEY_KP_7 + {0, '8', 0}, // KEY_KP_8 + {0, '9', 0}, // KEY_KP_9 + {'-', '-', 0}, // KEY_KP_DASH + {0, '4', 0}, // KEY_KP_4 + {0, '5', 0}, // KEY_KP_5 + {0, '6', 0}, // KEY_KP_6 + {'+', '+', 0}, // KEY_KP_PLUS + {0, '1', 0}, // KEY_KP_1 + {0, '2', 0}, // KEY_KP_2 + {0, '3', 0}, // KEY_KP_3 + {0, '0', 0}, // KEY_KP_0 + {127, ',', 0}, // KEY_KP_PERIOD + {0, 0, 0}, // KEY_SYSREQ + {0, 0, 0}, // KEY_EUROPE_2 + {'<', '>', '|'}, // KEY_F11 + {0, 0, 0}, // KEY_F12 + {0, 0, 0}, // KEY_KP_EQUAL +}; + +unsigned char Key::ascii() const { + // Select the correct table depending on the modifier bits. + // For the sake of simplicity, Shift and NumLock have precedence over Alt. + // The Ctrl modifier does not have a distinct table. + + if (!valid()) { + return '\0'; + } else if (shift || + (caps_lock && + ((scancode >= Scancode::KEY_Q && scancode <= Scancode::KEY_P) || + (scancode >= Scancode::KEY_A && scancode <= Scancode::KEY_L) || + (scancode >= Scancode::KEY_Z && + scancode <= Scancode::KEY_M))) || + (num_lock && scancode >= Scancode::KEY_KP_7 && + scancode <= Scancode::KEY_KP_PERIOD)) { + return ascii_tab[static_cast(scancode)].shift; + } else if (alt()) { + return ascii_tab[static_cast(scancode)].alt; + } else { + return ascii_tab[static_cast(scancode)].normal; + } +} diff --git a/kernel/object/key.h b/kernel/object/key.h new file mode 100644 index 0000000..d189544 --- /dev/null +++ b/kernel/object/key.h @@ -0,0 +1,163 @@ +/*! \file + * \brief \ref Key, an abstraction for handling pressed keys and their + * modifiers + */ + +#pragma once +#include "../types.h" + +/*! \brief Class that abstracts a key, made up of the scan code and the modifier + * bits. + */ +struct Key { + /*! \brief The keys' scan codes (code 1) + */ + enum class Scancode : uint8_t { + // Invalid scan code + KEY_INVALID = 0, + + // "real" valid scan codes + KEY_ESCAPE, + KEY_1, + KEY_2, + KEY_3, + KEY_4, + KEY_5, + KEY_6, + KEY_7, + KEY_8, + KEY_9, + KEY_0, + KEY_DASH, + KEY_EQUAL, + KEY_BACKSPACE, + KEY_TAB, + KEY_Q, + KEY_W, + KEY_E, + KEY_R, + KEY_T, + KEY_Y, + KEY_U, + KEY_I, + KEY_O, + KEY_P, + KEY_OPEN_BRACKET, + KEY_CLOSE_BRACKET, + KEY_ENTER, + KEY_LEFT_CTRL, + KEY_A, + KEY_S, + KEY_D, + KEY_F, + KEY_G, + KEY_H, + KEY_J, + KEY_K, + KEY_L, + KEY_SEMICOLON, + KEY_APOSTROPH, + KEY_GRAVE_ACCENT, + KEY_LEFT_SHIFT, + KEY_BACKSLASH, + KEY_Z, + KEY_X, + KEY_C, + KEY_V, + KEY_B, + KEY_N, + KEY_M, + KEY_COMMA, + KEY_PERIOD, + KEY_SLASH, + KEY_RIGHT_SHIFT, + KEY_KP_STAR, + KEY_LEFT_ALT, + KEY_SPACEBAR, + KEY_CAPS_LOCK, + KEY_F1, + KEY_F2, + KEY_F3, + KEY_F4, + KEY_F5, + KEY_F6, + KEY_F7, + KEY_F8, + KEY_F9, + KEY_F10, + KEY_NUM_LOCK, + KEY_SCROLL_LOCK, + KEY_KP_7, + KEY_KP_8, + KEY_KP_9, + KEY_KP_DASH, + KEY_KP_4, + KEY_KP_5, + KEY_KP_6, + KEY_KP_PLUS, + KEY_KP_1, + KEY_KP_2, + KEY_KP_3, + KEY_KP_0, + KEY_KP_PERIOD, + KEY_SYSREQ, + KEY_EUROPE_2, + KEY_F11, + KEY_F12, + KEY_KP_EQUAL, + + // Number of keys (excluding aliases below) + KEYS, + + // aliases + KEY_DIV = KEY_KP_7, + KEY_DEL = KEY_KP_PERIOD, + KEY_UP = KEY_KP_8, + KEY_DOWN = KEY_KP_2, + KEY_LEFT = KEY_KP_4, + KEY_RIGHT = KEY_KP_6, + }; + + Scancode scancode = Scancode::KEY_INVALID; + + // bit masks for the modifier keys + bool shift : 1 = false; + bool alt_left : 1 = false; + bool alt_right : 1 = false; + bool ctrl_left : 1 = false; + bool ctrl_right : 1 = false; + bool caps_lock : 1 = false; + bool num_lock : 1 = false; + bool scroll_lock : 1 = false; + + /*! \brief Default constructor: Instantiates an invalid key by setting + * ASCII, scan code, and modifier bits to 0 + */ + Key() {} + + /*! \brief Invalid keys have a scancode = 0 + * \return Checks whether a key is valid. + */ + bool valid() const { + return scancode != Scancode::KEY_INVALID && scancode < Scancode::KEYS; + } + + /*! \brief Marks the key as invalid by setting the scan code to 0. + */ + void invalidate() { scancode = Scancode::KEY_INVALID; } + + /*! \brief Get the key's ASCII value + * \return the key's ASCII value + */ + unsigned char ascii() const; + + /*! \brief Indicates whether the ALT modifier is set + * \return `true` if ALT key was pressed during key press + */ + bool alt() const { return alt_left || alt_right; } + + /*! \brief Indicates whether the CTRL modifier is set + * \return `true` if CTRL key was pressed during key press + */ + bool ctrl() const { return ctrl_left || ctrl_right; } +}; diff --git a/kernel/object/outputstream.cc b/kernel/object/outputstream.cc new file mode 100644 index 0000000..8a3c32e --- /dev/null +++ b/kernel/object/outputstream.cc @@ -0,0 +1,180 @@ +#include "outputstream.h" + +// operator <<: Converts the value in given data type to a string + +// Print a single character (trivial) +OutputStream& OutputStream::operator<<(char c) { + put(c); + return *this; +} + +OutputStream& OutputStream::operator<<(unsigned char c) { + return *this << static_cast(c); +} + +// Printing a null-terminated string +OutputStream& OutputStream::operator<<(const char* string) { + while ((*string) != '\0') { + put(*string); + string++; + } + return *this; +} + +OutputStream& OutputStream::operator<<(bool b) { + return *this << (b ? "true" : "false"); +} + +// Print integral numbers in number system base. +// All signed types are promoted to long long, +// all unsigned types to unsigned long long. + +OutputStream& OutputStream::operator<<(short ival) { + return *this << static_cast(ival); +} + +OutputStream& OutputStream::operator<<(unsigned short ival) { + return *this << static_cast(ival); +} + +OutputStream& OutputStream::operator<<(int ival) { + return *this << static_cast(ival); +} + +OutputStream& OutputStream::operator<<(unsigned int ival) { + return *this << static_cast(ival); +} + +OutputStream& OutputStream::operator<<(long ival) { + return *this << static_cast(ival); +} + +OutputStream& OutputStream::operator<<(unsigned long ival) { + return *this << static_cast(ival); +} + +// Print a signed , integral number. +OutputStream& OutputStream::operator<<(long long ival) { + /* Print '-' if number is negative + * + * In case ival is equal to LONG_LONG_MIN (0x8000000000000000), this + * multiplication with -1 will overflow and, as for all signed overflows, + * is not specified in C/C++. Thus, this operation will only work when + * the system uses two's complement: + * ~(0x8000000000000000) + 1 = 0x7fffffffffffffff + 1 = 0x8000000000000000 + * + * When casting 0x8000000000000000 to unsigned long long, the value will + * be (correctly) interpreted as -(LONG_LONG_MIN). + * + * A solution conforming (more) to the standard could be: + * if ((ival < 0) && (base == 10)) { + * put('-'); + * if (ival == LONG_LONG_MIN) { + * return *this << static_cast(LONG_LONG_MAX - + * (LONG_LONG_MAX + LONG_LONG_MIN)); } else { return *this << + * static_cast(-ival); + * } + * (However it introduces additional overhead) + */ + if ((ival < 0) && (base == 10)) { + put('-'); + ival = -ival; + } + // Print the remaining positive number using the unsigned output + return *this << static_cast(ival); +} + +// Print a unsigned, integral number. +OutputStream& OutputStream::operator<<(unsigned long long ival) { + if (base == 0) { + base = 16; + } + + if (base == 2) { + put('0'); + put('b'); + } else if (base == 8) { + put('0'); // octal numbers are prefixed with 0 + } else if (base == 16) { + put('0'); // hexadecimal numbers are prefixed with 0x + put('x'); + } + + // Determine the largest potency in the number system used, which is + // still smaller than the number to be printed + unsigned long long div = 1; + for (; ival / div >= static_cast(base); div *= base) { + } + + // print number char by char + for (; div > 0; div /= static_cast(base)) { + auto digit = ival / div; + if (digit < 10) { + put(static_cast('0' + digit)); + } else { + put(static_cast('a' + digit - 10)); + } + + ival %= div; + } + return *this; +} + +// Print a pointer as hexadecimal number +OutputStream& OutputStream::operator<<(const void* ptr) { + int oldbase = base; + base = 16; + *this << reinterpret_cast(ptr); + base = oldbase; + return *this; +} + +// Calls one of the manipulator functions +OutputStream& OutputStream::operator<<(OutputStream& (*f)(OutputStream&)) { + return f(*this); +} + +/* STREAM MANIPULATORS + * + * The functions below take and return a reference to an OutputStream object + * and are called by OutputStream& operator << (OutputStream& (*f) + * (OutputStream&)); The purpose of theses manipulator functions is modifying + * the behavior of the stream the are executed on, such as changing the number + * system. + */ + +// flush: Explicit buffer flush +OutputStream& flush(OutputStream& os) { + os.flush(); + return os; +} + +// endl: Inserts a newline to the output +OutputStream& endl(OutputStream& os) { + os << '\n' << flush; + return os; +} + +// bin: Selects the binary number system +OutputStream& bin(OutputStream& os) { + os.base = 2; + return os; +} + +// oct: Selects the octal number system +OutputStream& oct(OutputStream& os) { + os.base = 8; + return os; +} + +// dec: Selects the decimal number system +OutputStream& dec(OutputStream& os) { + os.base = 10; + return os; +} + +// hex: Selects the hexadecimal number system +OutputStream& hex(OutputStream& os) { + os.base = 16; + return os; +} diff --git a/kernel/object/outputstream.h b/kernel/object/outputstream.h new file mode 100644 index 0000000..620c2ee --- /dev/null +++ b/kernel/object/outputstream.h @@ -0,0 +1,209 @@ +/*! \file + * \brief This file contains the \ref OutputStream + * + * Along with the class OutputStream itself, this file contains definitions for + * the manipulators \ref hex, \ref dec, \ref oct, and \ref bin, which are used + * for changing the radix, and \ref endl for signaling the end of the current + * line. + * \ingroup io + * + * \par Manipulators + * To simplify formatting text and numbers using the class OutputStream, we + * define so-called manipulators. For example, the expression kout << "a = " + * << dec << a << " is hexadecimal " << hex << a << endl; should, at first, + * print the value stored in decimal and then in hexadecimal form, followed by a + * line break. The intended properties can be realized by implementing \ref hex, + * \ref dec, \ref oct, \ref bin, and \ref endl as functions (i.e., they are, in + * particular, not methods of \ref OutputStream) that take (as first parameter) + * and return a reference to an OutputStream object. When compiling the + * expression shown above, the method OutputStream& OutputStream::operator<< + * ((*f*) (OutputStream&)) is chosen when one of the functions \ref hex, + * \ref dec, \ref oct, \ref bin, or \ref endl is streamed into an \ref + * OutputStream, which finally will execute the passed function. + * + * \note The term manipulator originates from the book + * [The C++ Programming Language](http://www.stroustrup.com/4th.html) + * by Bjarne Stroustrup. Refer to this book for further explanations. + */ + +#pragma once +#include "./stringbuffer.h" +#include "types.h" + +/*! \brief The class OutputStream corresponds, essentially, to the class ostream + * from the C++ IO-Stream library. + * + * As relying on the method \ref Stringbuffer::put() is quite cumbersome when + * not only printing single characters, but numbers and whole strings, the + * class OutputStream provides a convenient way of composing output of + * variables of varying data types. Therefore, OutputStream implements shift + * operators `operator<<`` for various data types (similar to those known from + * the C++ IO-Stream library) + * + * For further convenience, OutputStream also allows printing integral numbers + * in decimal, binary, octal, and hexadecimal format. Remember that, for + * negative numbers, the sign is only printed when using the decimal number + * system; for binary, octal, and hex, the number is printed as stored in the + * machine word without interpreting the sign. For Intel CPUs, two's complement + * is used for storing negative values, `-1`, for example, will print hex + * `FFFFFFFF` and octal `37777777777`. + * + * OutputStream's public methods/operators all return a reference to the object + * they are called on (i.e. `*this`). Returning `*this` allows chaining those + * stream operators in a single expression, such as + * kout << "a = " << a; + * + * At this point in time, OutputStream implements `operator<<`` for chars, + * strings and whole numbers. An additional `operator<<` allows using + * manipulators whose detailed description is given below. + */ + +class OutputStream : public Stringbuffer { + OutputStream(const OutputStream&) = delete; + OutputStream& operator=(const OutputStream&) = delete; + + public: + /*! \brief Number system used for printing integral numbers (one of 2, + * 8, 10, or 16) + */ + int base = 10; + + /*! \brief Default constructor. Initial number system is decimal. + * + */ + constexpr OutputStream() {} + + /*! \brief Destructor + */ + virtual ~OutputStream() {} + + /*! \brief Clears the buffer. + * + * Pure virtual method that must be implemented by derived + * (non-abstract) classes. + * Formatting of the buffer contents can be implemented differently by + * different derived classes + */ + virtual void flush() = 0; + + /*! \brief Print a single character + * + * \param c Character to be printed + * \return Reference to OutputStream os; allows operator chaining. + */ + OutputStream& operator<<(char c); + + /*! \brief Print a single character + * \note In C, there are no "characters" in that sense, but only + * integers. A `char`, therefore, is a 8 bit number with the most + * significant bit (optionally) representing a sign. + * Depending on whether signed or not, the value ranges are [-128, 127] + * or [0; 255]. For GCC, a `char` is a `signed char`. + * + * \param c Character to be printed + * \return Reference to OutputStream os; allows operator chaining. + */ + OutputStream& operator<<(unsigned char c); + + /*! \brief Printing a null-terminated string + * + * \param string String to be printed + * \return Reference to OutputStream os; allows operator chaining. + */ + OutputStream& operator<<(const char* string); + + /*! \brief Print a boolean value + * + * \param b Boolean to be printed + * \return Reference to OutputStream os; allows operator chaining. + */ + OutputStream& operator<<(bool b); + + /*! \brief Print an integral number in radix base + * + * \param ival Number to be printed + * \return Reference to OutputStream os; allows operator chaining. + */ + OutputStream& operator<<(short ival); + + /// \copydoc OutputStream::operator<<(short) + OutputStream& operator<<(unsigned short ival); + + /// \copydoc OutputStream::operator<<(short) + OutputStream& operator<<(int ival); + + /// \copydoc OutputStream::operator<<(short) + OutputStream& operator<<(unsigned int ival); + + /// \copydoc OutputStream::operator<<(short) + OutputStream& operator<<(long ival); + + /// \copydoc OutputStream::operator<<(short) + OutputStream& operator<<(unsigned long ival); + + /// \copydoc OutputStream::operator<<(short) + OutputStream& operator<<(long long ival); + + /// \copydoc OutputStream::operator<<(short) + OutputStream& operator<<(unsigned long long ival); + + /*! \brief Print a pointer as hexadecimal number + * + * \param ptr Pointer to be printed + * \return Reference to OutputStream os; allows operator chaining. + */ + OutputStream& operator<<(const void* ptr); + + /*! \brief Calls one of the manipulator functions. + * + * Method that calls the manipulator functions defined below, which + * allow modifying the stream's behavior by, for instance, changing the + * number system. + * + * \param f Manipulator function to be called + * \return Reference to OutputStream os; allows operator chaining. + */ + OutputStream& operator<<(OutputStream& (*f)(OutputStream&)); +}; + +/*! \brief Enforces a buffer flush. + * + * \param os Reference to stream to be flushed. + * \return Reference to OutputStream os; allows operator chaining. + */ +OutputStream& flush(OutputStream& os); + +/*! \brief Prints a newline character to the stream and issues a buffer flush. + * + * \param os Reference to stream to be modified. + * \return Reference to OutputStream os; allows operator chaining. + */ +OutputStream& endl(OutputStream& os); + +/*! \brief Print subsequent numbers in binary form. + * + * \param os Reference to stream to be modified. + * \return Reference to OutputStream os; allows operator chaining. + */ +OutputStream& bin(OutputStream& os); + +/*! \brief Print subsequent numbers in octal form. + * + * \param os Reference to stream to be modified. + * \return Reference to OutputStream os; allows operator chaining. + */ +OutputStream& oct(OutputStream& os); + +/*! \brief Print subsequent numbers in decimal form. + * + * \param os Reference to stream to be modified. + * \return Reference to OutputStream os; allows operator chaining. + */ +OutputStream& dec(OutputStream& os); + +/*! \brief Print subsequent numbers in hex form. + * + * \param os Reference to stream to be modified. + * \return Reference to OutputStream os; allows operator chaining. + */ +OutputStream& hex(OutputStream& os); diff --git a/kernel/object/queue.h b/kernel/object/queue.h new file mode 100644 index 0000000..7f49815 --- /dev/null +++ b/kernel/object/queue.h @@ -0,0 +1,271 @@ +/*! \file + * \brief Templated \ref Queue for arbitrary objects. + */ + +#pragma once +#include "../arch/core.h" +#include "../debug/assert.h" +#include "../object/outputstream.h" +#include "../types.h" + +/*! \brief Templated Queue for arbitrary objects. + * + * Queue is implemented by a head-object (Queue) and next-pointers embedded + * in the queued objects. By passing a different get_link function into the + * constructor, the member name of the next-pointer can be changed and objects + * can be contained in different independent queues. + */ +template +class Queue { + /// Default get_link implementation returns a pointer to the next-pointer. + static T** default_get_link(T& obj) { return &obj.queue_link; } + /// Type definition for the get_link function + typedef T** (*NextFunc)(T&); + + /// Function pointer to the get_link function, called whenever the + /// next pointer array is referenced + const NextFunc get_link = default_get_link; + /// head points to the first element (the one returned on first dequeue). + /// Can be nullptr if the queue is empty. + T* head = nullptr; + /// tail points to the last element (the one last added). + /// Is only valid if head != nullptr + T* tail = nullptr; + + // Prevent copies and assignments + Queue(const Queue&) = delete; + Queue& operator=(const Queue&) = delete; + + public: + /*! \brief Minimal forward iterator + * You can use this iterator to iterate the queue like a normal STL + * container. It only supports forward iteration, since the queue is single + * linked. + */ + class Iterator { + private: + Queue& queue; + T* current; + friend class Queue; + Iterator(Queue& queue, T* current) + : queue(queue), current(current) {} + + public: + Iterator operator+(unsigned num) { + if (current == nullptr) { + return *this; + } + T* temp = current; + while (num--) { + temp = queue.next(*temp); + } + return Iterator(queue, temp); + } + + // pre increment + Iterator& operator++() { + current = queue.next(*current); + return *this; + } + + // post increment + Iterator operator++(int) { + auto temp = Iterator(queue, current); + current = queue.next(*current); + return temp; + } + + T* operator*() { return current; } + + bool operator==(const Iterator& other) { + return current == other.current; + } + + bool operator!=(const Iterator& other) { return !(*this == other); } + }; + + constexpr Queue(Queue&&) = default; + + /*! \brief Constructor + * \param[in] get_link A function pointer to the get_link, i.e. a function + * which returns a pointer to the next-pointer of an + * element in the Queue. + */ + constexpr explicit Queue(NextFunc get_link = default_get_link) + : get_link(get_link) { + assert(get_link != nullptr && + "get_link function pointer must not be nullptr!"); + } + + /*! \brief Enqueues the provided item at the end of the queue. If the + *element is already contained in the queue, false will be returned + * \param[in] item element to be appended (enqueued). + * \return false if the element already was enqueued (and nothing was done) + * or not (and it is now enqueued, then true) + */ + bool enqueue(T& item) { + T** nextptr = get_link(item); + if (*nextptr != nullptr || (head != nullptr && tail == &item)) { + return false; + } + *nextptr = nullptr; + + if (head == nullptr) { + head = tail = &item; + } else { + assert(tail != nullptr); + *get_link(*tail) = &item; + tail = &item; + } + return true; + } + + /*! \brief insert a new element at the start of the queue + * \param[in] item the new item to add + * \return true if successful, false if item was already in the queue + **/ + bool insertFirst(T& item) { + T** nextptr = get_link(item); + if (*nextptr != nullptr || (head != nullptr && tail == &item)) { + return false; + } + + if (head == nullptr) { + tail = &item; + } + *nextptr = head; + head = &item; + return true; + } + + /*! \brief Insert a new element item into the list after an element after. + * Returns false if item is already in the/a list or after is not in this + *list + * \param[in] after the element after which the new one should be inserted + * \param[in] item the new element to add + * \return true if successful, false if item was in the list or after was + *not + **/ + bool insertAfter(T& after, T& item) { + // if queue is empty there is no after + // and tail is not valid so we need to check head here + if (head == nullptr) { + return false; + } + + if (&after == tail) { + return enqueue(item); + } + T** nextptr = get_link(item); + // if item is already in the list return false + if (*nextptr != nullptr || tail == &item) { + return false; + } + + T** pnextptr = get_link(after); + // if after is NOT in the list, return false + if (!(pnextptr != nullptr || tail == &after)) { + return false; + } + + *nextptr = *pnextptr; + *pnextptr = &item; + return true; + } + + /*! \brief return the next element of a given one or nullptr if the end is + *reached + * \param[in] item the current item + * \return the next element or nullptr if the end is reached or the item is + *not in this list + **/ + T* next(T& item) { + T** nextptr = get_link(item); + if (head == nullptr || (*nextptr == nullptr && tail != &item)) { + return nullptr; + } + + return *nextptr; + } + + /*! \brief Return whether or not the queue is empty + * \return True if the queue is empty or false otherwise. + */ + bool is_empty() const { return (head == nullptr); } + + /*! \brief Removes the first element in the queue and returns it. + * \note Does not update the tail-pointer + * \return Pointer to the removed item or `nullptr` if the queue was empty. + */ + T* dequeue() { + T* out = head; + if (head != nullptr) { + T** nextptr = get_link(*head); + head = *nextptr; + *nextptr = nullptr; + } + return out; + } + + /*! \brief Removes a given element from the queue and returns that element, + * or nullptr if it was not present + * \return pointer to the removed element, or nullptr if not present + */ + T* remove(T* that) { + if (!that) return nullptr; + T* cur = head; + T** next_link; + + if (head == that) { + head = *get_link(*head); + + *get_link(*that) = nullptr; + return that; + } + while (cur) { + next_link = get_link(*cur); + if (*next_link == that) { + *next_link = *get_link(**next_link); + + if (that == tail) { + tail = cur; + } + + *get_link(*that) = nullptr; + return that; + } + cur = *next_link; + } + return nullptr; + } + + /// get an iterator to the first element + Queue::Iterator begin() { return Queue::Iterator(*this, head); } + + /// get an iterator that marks the end of list + Queue::Iterator end() { return Queue::Iterator(*this, nullptr); } + + /// get the first element of the queue + T* first() { return head; } + + /// get the last element of the queue + T* last() { return (head == nullptr ? nullptr : tail); } +}; + +/*! \brief Overload stream operator for list printing. + * + * With this a list can be printed. The elements itself are not printed, just + * the pointer. + */ +template +OutputStream& operator<<(OutputStream& os, Queue& queue) { + os << "{"; + for (typename Queue::Iterator it = queue.begin(); it != queue.end(); + ++it) { + os << *it; + if (it + 1 != queue.end()) { + os << ", "; + } + } + return os << "}"; +} diff --git a/kernel/object/stringbuffer.cc b/kernel/object/stringbuffer.cc new file mode 100644 index 0000000..18e07bd --- /dev/null +++ b/kernel/object/stringbuffer.cc @@ -0,0 +1,11 @@ +#include "stringbuffer.h" + +void Stringbuffer::put(char c) { + if (pos < (sizeof(buffer) - 1)) { + buffer[pos++] = c; + buffer[pos] = '\0'; + } + if (pos >= (sizeof(buffer) - 1)) { + flush(); + } +} diff --git a/kernel/object/stringbuffer.h b/kernel/object/stringbuffer.h new file mode 100644 index 0000000..106d1b9 --- /dev/null +++ b/kernel/object/stringbuffer.h @@ -0,0 +1,75 @@ +/*! \file + * \brief \ref Stringbuffer composes single characters into a buffer + */ + +#pragma once +#include "types.h" + +/*! \brief The class Stringbuffer composes single characters into a longer text + * that can be processed on block. + * + * To make Stringbuffer as versatile as possible, the class does make + * assumptions about neither the underlying hardware, nor the meaning of + * "processing". When flush() is called (i.e., either on explicit request or + * once the buffer is full). To be hardware independent, flush() is to be + * implemented by the derived classes. + * + * \par Hints for Implementation + * Use a buffer of fixed size for caching characters, which should be + * accessible by derived classes. + * Keep in mind that the derived implementation of flush() will need to know + * about numbers of characters in the buffer. + * + * \par Notes + * Reason for the existence of this class is that generating longer texts is + * often implemented by assembly of small fragments (such as single characters + * or numbers). + * However, writing such small fragments directly to (for example) screen is + * quite inefficient (e.g., due to the use of IO ports, syscalls, or locks) and + * can be improved drastically by delaying the output step until the assembly + * is finished (or the buffer runs full). + */ +class Stringbuffer { + // Prevent copies and assignments + Stringbuffer(const Stringbuffer&) = delete; + Stringbuffer& operator=(const Stringbuffer&) = delete; + + // All variables and methods are protected in this class, + // as the derived classes need direct access to be buffer, + // the constructor, the destructor, and the method put. + // flush() is to be implemented either way and may be redefined + // as public. + + protected: + /// buffer containing characters that will be printed upon flush() + /// put() keeps this buffer always '\0'-terminated + char buffer[80 + 1] = {0}; + /// current position in the buffer + long unsigned pos = 0; + /*! \brief Constructor; Marks the buffer as empty + */ + constexpr Stringbuffer() {} + + /*! \brief Inserts a character into the buffer. + * + * Once the buffer is full, a call to flush() will be issued and + * thereby clearing the buffer. + * + * \param c Char to be added + * + */ + void put(char c); + + /*! \brief Flush the buffer contents + * + * This method is to be defined in derived classes, as only those know + * how to print characters. + * flush() is required to reset the position pos. + */ + virtual void flush() = 0; + + public: + /*! \brief Destructor (nothing to do here) + */ + virtual ~Stringbuffer() {} +}; diff --git a/kernel/sync/bellringer.cc b/kernel/sync/bellringer.cc new file mode 100644 index 0000000..f19c1c4 --- /dev/null +++ b/kernel/sync/bellringer.cc @@ -0,0 +1,67 @@ +#include "./bellringer.h" + +#include "../arch/lapic.h" +#include "../debug/assert.h" +#include "../interrupt/guard.h" +#include "arch/core_interrupt.h" + +// check: Checks whether bells are running out of time and rings them if +// necessary +void Bellringer::check(Vault &vault) { + if (Bell *bell = bells.first()) { + bell->counter--; + while ((bell = bells.first()) && bell->counter == 0) { + bells.dequeue(); + vault.scheduler.ready(bell->thread); + } + } +} + +// job: Give a bell to the bellringer & ring it when the specified time ran out. +void Bellringer::sleep(Vault &vault, unsigned int ms) { + Bell bell_tmp; + Bell *bell = &bell_tmp; + bell->thread = vault.scheduler.active(); + + assert(bell != nullptr); + unsigned int ticks = ms * 1000 / LAPIC::Timer::interval(); + assert(ticks != 0); + if (bells.first() == nullptr) { + // queue is empty; enqueue new bell as first element + bells.enqueue(*bell); + } else { + // To reduce the amount of work done in Bellringer::check (which + // is called frequently), we sort the queue by relative waiting + // times: Each bell is assigned the delta between its waiting + // time and its predecessor's waiting time. + // This allows us to only "tick" the first bell. + + Bell *next = nullptr; + Bell *pred = nullptr; + for (Bell *p = bells.first(); p != nullptr; p = bells.next(*p)) { + if (ticks < p->counter) { + next = p; + break; + } + ticks -= p->counter; + pred = p; + } + // If there is a predecessor, enqueue the bell after pred; + // otherwise insert at the beginning. + if (pred != nullptr) { + bells.insertAfter(*pred, *bell); + } else { + bells.insertFirst(*bell); + } + // If we have a predecessor, reduce its waiting time by our waiting + // time, as _next_ will have to wait until we finished waiting. + if (next != nullptr) { + next->counter -= ticks; + } + } + bell->counter = ticks; + vault.scheduler.resume(false); +} + +// Are there bells in the queue? +bool Bellringer::bellPending() const { return !bells.is_empty(); } diff --git a/kernel/sync/bellringer.h b/kernel/sync/bellringer.h new file mode 100644 index 0000000..2edabaf --- /dev/null +++ b/kernel/sync/bellringer.h @@ -0,0 +1,79 @@ +/*! \file + * \brief \ref Bellringer that manages and activates time-triggered activities. + */ + +#pragma once +#include "../object/queue.h" +#include "../thread/thread.h" +#include "../types.h" + +struct Vault; + +/*! \brief Manages and activates time-triggered activities. + * \ingroup ipc + * + * The Bellringer is regularly activated and checks whether any of the bells + * should ring. The bells are stored in a Queue that is managed by the + * Bellringer. A clever implementation avoids iterating through the whole list + * for every iteration by keeping the bells sorted and storing delta times. This + * approach leads to a complexity of O(1) for the method called by the timer + * interrupt in case no bells need to be rung. + */ +class Bellringer { + // Prevent copies and assignments + Bellringer(const Bellringer&) = delete; + Bellringer& operator=(const Bellringer&) = delete; + + /** + * @brief Contains a Thread and its remaining waiting time in timer ticks + * + */ + struct Bell { + // link pointer to the next bell in the bellringer's bell list + Bell* queue_link = nullptr; + + Thread* thread; + size_t counter; + }; + + /*! \brief List of bells currently managed. + * + * This list contains non-expired bells enqueued by job(). + * These bells will be checked on every call to check(). + * + * All elements that should be inserted into a Queue instance + * are required to be derived from Queue::Node. + */ + Queue bells; + + public: + // constructor + Bellringer() {} + + /*! \brief Checks whether there are bells to be rung. + * + * Every call to check elapses a tick. Once such a tick reduces a bell's + * remaining time to zero, the bell will be rung (i.e., its thread is + * ready). + * + * \param vault The vault containing the bellringer instance + * + */ + void check(Vault& vault); + + /*! \brief Puts the calling thread to sleep for `ms` milliseconds by + * enqueuing a \ref Bell. + * + * \param vault The vault containing the bellringer instance + * \param ms Number of milliseconds that should be waited before + * ringing the bell + * + */ + void sleep(Vault& vault, unsigned int ms); + + /*! \brief Checks whether there are enqueued bells. + * \return true if there are enqueued bells, false otherwise + * + */ + bool bellPending() const; +}; diff --git a/kernel/sync/message.h b/kernel/sync/message.h new file mode 100644 index 0000000..3f019ff --- /dev/null +++ b/kernel/sync/message.h @@ -0,0 +1,44 @@ +#pragma once +#include "../object/queue.h" +#include "../types.h" + +struct Message { + const size_t pid; ///< Sender Thread ID of message + + const uintptr_t sbuffer; ///< Send buffer + const size_t ssize; ///< Send buffer size + + const uintptr_t rbuffer; ///< Receive buffer + const size_t rsize; ///< Receive buffer size + + Message *queue_link = nullptr; ///< Next message in the message queue + + /*! \brief Constructor + * \param pid Sender Thread ID of message + * \param sbuffer Send buffer + * \param ssize Send buffer size + * \param rbuffer Receive buffer + * \param rsize Receive buffer size + */ + explicit Message(int pid, uintptr_t sbuffer = 0, size_t ssize = 0, + uintptr_t rbuffer = 0, size_t rsize = 0) + : pid(pid), + sbuffer(sbuffer), + ssize(ssize), + rbuffer(rbuffer), + rsize(rsize) {} + + /*! \brief Helper to retrieve (and remove) a message from the queue + * \param pid Thread id of message + * \param queue Queue with message + * \return Pointer to message or nullptr + */ + static Message *dequeueByPID(size_t pid, Queue &queue) { + for (Message *m : queue) { + if (m->pid == pid) { + return queue.remove(m); + } + } + return nullptr; + } +}; diff --git a/kernel/sync/semaphore.cc b/kernel/sync/semaphore.cc new file mode 100644 index 0000000..fd7603f --- /dev/null +++ b/kernel/sync/semaphore.cc @@ -0,0 +1,22 @@ +#include "./semaphore.h" + +#include "../interrupt/guard.h" +#include "../thread/thread.h" + +void Semaphore::p(Vault &vault) { + if (counter == 0) { + waiting.enqueue(*vault.scheduler.active()); + vault.scheduler.resume(false); + } else { + counter--; + } +} + +void Semaphore::v(Vault &vault) { + Thread *customer = waiting.dequeue(); + if (customer != nullptr) { + vault.scheduler.ready(customer); + } else { + counter++; + } +} diff --git a/kernel/sync/semaphore.h b/kernel/sync/semaphore.h new file mode 100644 index 0000000..cb0a9bd --- /dev/null +++ b/kernel/sync/semaphore.h @@ -0,0 +1,53 @@ +#pragma once +#include "../object/queue.h" +#include "../types.h" + +/*! \file + * \brief \ref Semaphore for synchronization of threads. + */ + +/*! + * \defgroup ipc Inter-Process Communication + * \brief Communication between threads + */ + +// Forward declarations to break cyclic includes +struct Vault; +class Thread; + +/*! \brief Semaphore used for synchronization of threads. + * \ingroup ipc + * + * The class Semaphore implements the concept of counting semaphores. + * Waiting threads are parked inside a \ref Queue. + */ +class Semaphore { + // Prevent copies and assignments + Semaphore(const Semaphore&) = delete; + Semaphore& operator=(const Semaphore&) = delete; + unsigned counter; + Queue waiting; + + public: + /*! \brief Constructor; initialized the counter with provided value `c` + * \param c Initial counter value + */ + explicit Semaphore(unsigned c = 0) : counter(c) {} + + /*! \brief Wait for access to the critical area. + * + * Enter/decrement/wait operation: If the counter is greater than 0, then + * it is decremented by one. Otherwise the calling thread will be enqueued + * to wait until it can do that. + * + */ + void p(Vault& vault); + + /*! \brief Leave the critical area. + * + * Leave/increment operation: If there are threads waiting, wake the + * first one; otherwise increment the counter by one. + * + */ + void v(Vault& vault); +}; diff --git a/kernel/syscall/handler.asm b/kernel/syscall/handler.asm new file mode 100644 index 0000000..ac9830b --- /dev/null +++ b/kernel/syscall/handler.asm @@ -0,0 +1,41 @@ +; Generic high-level syscall handler +[EXTERN syscall_handler] + +; Low-level interrupt based system call entry function +[GLOBAL syscall_entry] + +[SECTION .text] + +; The SystemV ABI for x64 uses the register `rdi`, `rsi`, `rdx`, `rcx`, `r8` and +; `r9` to pass the first six parameters of a function. Since every syscall can +; have a maximum of 5 parameters, these register will just be forwarded (without +; requiring any additional operation), having the syscall number stored in `rdi`. +; The return value will be stored in `rax`. +ALIGN 8 +syscall_entry: + ; Interrupt Context Pointer (7th Parameter) + push rsp + + ; Clear direction flag for string operations + cld + + ; Call the high-level (C++) system call handler + call syscall_handler + + ; Optional: Prevent kernel information leakage + ; by zeroing scratch registers + mov rdi, 0 + mov rsi, 0 + mov rdx, 0 + mov rcx, 0 + mov r8, 0 + mov r9, 0 + mov r10, 0 + mov r11, 0 + + ; Drop 7th parameter + add rsp, 8 + + ; Return from interrupt entry function + iretq + diff --git a/kernel/syscall/handler.cc b/kernel/syscall/handler.cc new file mode 100644 index 0000000..0471cc4 --- /dev/null +++ b/kernel/syscall/handler.cc @@ -0,0 +1,56 @@ +#include "syscall/handler.h" + +#include "arch/core.h" +#include "arch/core_interrupt.h" +#include "arch/gdt.h" +#include "arch/idt.h" +#include "debug/kernelpanic.h" +#include "debug/output.h" +#include "interrupt/guard.h" +#include "syscall/skeleton.h" +#include "syscall/stub.h" +#include "types.h" + +/*! \brief Interrupt based system call entry function + * + * Low-level function written in assembly (located in `syscall/handler.asm`), + * calls \ref syscall_handler + */ +extern "C" [[gnu::interrupt]] void syscall_entry(InterruptContext *context); + +namespace Syscall { +/*! \brief High level system call handler + * called by both low level handler in `syscall/handler.asm`. + * + * Processes the request by delegating it to the appropriate function identified + * by the system call number -- allowing up to five parameters for the system + * call. + * + * \param p1 first parameter + * \param p2 second parameter + * \param p3 third parameter + * \param p4 fourth parameter + * \param p5 fifth parameter + * \param sysnum identifier for the system call + * \param user pointer to the interrupt \ref context (for example to determine + * instruction pointer) + * \return system call return value + */ +extern "C" size_t syscall_handler(size_t sysnum, size_t p1, size_t p2, + size_t p3, size_t p4, size_t p5, + InterruptContext *user) { + (void)p1; + (void)p2; + (void)p3; + (void)p4; + (void)p5; + (void)sysnum; + (void)user; + return static_cast(-1); +} + +void init() { + // Set interrupt based syscall handler +} + +} // namespace Syscall diff --git a/kernel/syscall/handler.h b/kernel/syscall/handler.h new file mode 100644 index 0000000..31bc7f3 --- /dev/null +++ b/kernel/syscall/handler.h @@ -0,0 +1,11 @@ +#pragma once + +/*! \brief User mode system calls + */ +namespace Syscall { + +/*! \brief Setup Syscalls Interrupt + * \param vector valid interrupt vector number (32-255) + */ +void init(); +} // namespace Syscall diff --git a/kernel/syscall/skeleton.cc b/kernel/syscall/skeleton.cc new file mode 100644 index 0000000..33e0b5c --- /dev/null +++ b/kernel/syscall/skeleton.cc @@ -0,0 +1,71 @@ +#include "syscall/skeleton.h" + +#include "debug/kernelpanic.h" +#include "debug/output.h" +#include "device/textstream.h" +#include "interrupt/guard.h" +#include "sync/semaphore.h" +#include "thread/scheduler.h" + +void *operator new(size_t, void *); + +namespace Syscall { +namespace Skeleton { +size_t test(Vault &vault, size_t p1, size_t p2, size_t p3, size_t p4, + size_t p5) { + (void)vault; + vault.kout << "test(" << p1 << ", " << p2 << ", " << p3 << ", " << p4 + << ", " << p5 << ");" << endl; + return 0xdeadbeef; +} + +int getpid(Vault &vault) { + (void)vault; + return -1; +} + +size_t write(Vault &vault, uint32_t id, const void *buffer, size_t size) { + (void)vault; + (void)id; + (void)buffer; + (void)size; + return 0; +} + +size_t read(Vault &vault, uint32_t id) { + (void)vault; + (void)id; + return 0; +} + +void sleep(Vault &vault, size_t ms) { + (void)vault; + (void)ms; +} + +bool sem_init(Vault &vault, size_t id, uint32_t value) { + (void)vault; + (void)id; + (void)value; + return false; +} + +void sem_destroy(Vault &vault, size_t id) { + (void)vault; + (void)id; +} + +void sem_signal(Vault &vault, size_t id) { + (void)vault; + (void)id; +} + +void sem_wait(Vault &vault, size_t id) { + (void)vault; + (void)id; +} + +void exit(Vault &vault) { (void)vault; } + +} // namespace Skeleton +} // namespace Syscall diff --git a/kernel/syscall/skeleton.h b/kernel/syscall/skeleton.h new file mode 100644 index 0000000..5f9f831 --- /dev/null +++ b/kernel/syscall/skeleton.h @@ -0,0 +1,28 @@ +#pragma once + +#include "types.h" + +struct Vault; + +namespace Syscall { + +/*! \brief Implementation of the functionality provided via syscalls + */ +namespace Skeleton { + +size_t test(Vault &vault, size_t p1, size_t p2, size_t p3, size_t p4, + size_t p5); + +int getpid(Vault &vault); +size_t write(Vault &vault, uint32_t id, const void *buffer, size_t size); +size_t read(Vault &vault, uint32_t id); +void sleep(Vault &vault, size_t ms); +bool sem_init(Vault &vault, size_t id, uint32_t value); +void sem_destroy(Vault &vault, size_t id); +void sem_signal(Vault &vault, size_t id); +void sem_wait(Vault &vault, size_t id); +void exit(Vault &vault); +void kill(Vault &vault, size_t pid); + +} // namespace Skeleton +} // namespace Syscall diff --git a/kernel/syscall/stub.asm b/kernel/syscall/stub.asm new file mode 100644 index 0000000..4c28098 --- /dev/null +++ b/kernel/syscall/stub.asm @@ -0,0 +1,10 @@ +[SECTION .text] + +;; sys_call +;; Globally visible +[GLOBAL sys_call] +align 8 +sys_call: + ; BSB2 1 - Syscall stub + + diff --git a/kernel/syscall/stub.h b/kernel/syscall/stub.h new file mode 100644 index 0000000..5b219e8 --- /dev/null +++ b/kernel/syscall/stub.h @@ -0,0 +1,24 @@ +#pragma once +#include "types.h" + +namespace Syscall { +/*! \brief Syscall IDs + * \note the syscall number must correspond to the values in the syscall stub! + */ +enum class ID : size_t { + TEST = 0, +}; +} // namespace Syscall + +/// \brief Syscall stub +extern "C" ssize_t sys_call(Syscall::ID id, size_t p1, size_t p2, size_t p3, + size_t p4, size_t p5); +extern "C" ssize_t sys_safe_call(Syscall::ID id, size_t p1, size_t p2, + size_t p3, size_t p4, size_t p5); + +// Interrupt based syscalls +[[gnu::always_inline]] static inline ssize_t sys_test(size_t p1, size_t p2, + size_t p3, size_t p4, + size_t p5) { + return sys_call(Syscall::ID::TEST, p1, p2, p3, p4, p5); +} diff --git a/kernel/thread/dispatcher.cc b/kernel/thread/dispatcher.cc new file mode 100644 index 0000000..65d6ccc --- /dev/null +++ b/kernel/thread/dispatcher.cc @@ -0,0 +1,26 @@ +// vim: set noet ts=4 sw=4: + +#include "dispatcher.h" + +#include "../arch/core.h" +#include "../debug/output.h" // IWYU pragma: keep + +Dispatcher::Dispatcher() : life(nullptr) {} + +Thread *Dispatcher::active() const { return life; } + +void Dispatcher::go(Thread *first) { + assert(active() == nullptr); + setActive(first); + first->go(); +} + +void Dispatcher::dispatch(Thread *next) { + Thread *current = active(); + assert(current != nullptr); + if (current != next) { + setActive(next); + + current->resume(next); + } +} diff --git a/kernel/thread/dispatcher.h b/kernel/thread/dispatcher.h new file mode 100644 index 0000000..8cd3114 --- /dev/null +++ b/kernel/thread/dispatcher.h @@ -0,0 +1,53 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief \ref Dispatcher for \ref Thread threads + */ +#pragma once +#include "../thread/thread.h" +#include "../types.h" + +/*! \brief The dispatcher dispatches threads and puts the scheduler's + * decisions into action. + * \ingroup thread + * + * The dispatcher manages the life pointer that refers to the currently + * active thread and performs the actual switching of processes. + * For single-core systems, a single life pointer is sufficient, as only a + * single thread can be active at any one time. On multi-core systems, + * every CPU core needs its own life pointer. + */ +class Dispatcher { + Thread* life; + + /*! \brief set the currently active thread + * \param thread active Thread + */ + void setActive(Thread* thread) { life = thread; } + + public: + /*! \brief constructor + * + */ + Dispatcher(); + + /*! \brief Returns the thread running on the CPU core calling this method + * + */ + Thread* active() const; + + /*! \brief This method stores first as life pointer for this CPU core and + * triggers the execution of first. Only to be used for the first thread + * running on a CPU. + * \param first First thread to be executed on this CPU core. + * + */ + void go(Thread* first); + + /*! \brief Updates the life pointer to next and issues a thread change from + * the old to the new life pointer. + * \param next Next thread to be executed. + * + */ + void dispatch(Thread* next); +}; diff --git a/kernel/thread/idlethread.cc b/kernel/thread/idlethread.cc new file mode 100644 index 0000000..934f3e9 --- /dev/null +++ b/kernel/thread/idlethread.cc @@ -0,0 +1,31 @@ +#include "idlethread.h" + +#include "../arch/core.h" +#include "../arch/lapic.h" +#include "../debug/output.h" +#include "../interrupt/guard.h" +#include "../thread/scheduler.h" + +void IdleThread::action() { + while (true) { + Core::Interrupt::disable(); + if (Guard::unsafeConstAccess() + .scheduler.isEmpty()) { // XXX: not a fan ... + // To save energy we can disable the timer on a core as soon as no + // clock needs to be managed. This function is called from the idle + // loop. + bool can_sleep = + !Guard::unsafeConstAccess().bellringer.bellPending(); + if (can_sleep) { + LAPIC::Timer::setMasked(true); + } + Core::idle(); + // We woke up. Start ticking again + LAPIC::Timer::setMasked(false); + } else { + Core::Interrupt::enable(); + Guarded g = Guard::enter(); + g.vault().scheduler.resume(); + } + } +} diff --git a/kernel/thread/idlethread.h b/kernel/thread/idlethread.h new file mode 100644 index 0000000..e6fa0f3 --- /dev/null +++ b/kernel/thread/idlethread.h @@ -0,0 +1,28 @@ +/*! \file + * \brief \ref IdleThread executed by the \ref Scheduler if no other \ref + * Thread is ready + */ + +#pragma once +#include "../types.h" +#include "thread.h" + +/*! \brief Thread that is executed when there is nothing to do for this core. + * \ingroup thread + * + * Using the IdleThread simplifies the idea of waiting and is an answer to the + * questions that arise once the ready queue is empty. + * + * \note Instance of this class should *never* be inserted into the scheduler's + * ready queue, as the IdleThread should only be executed if there is no + * proper work to do. + */ +class IdleThread : public Thread { + public: + explicit IdleThread() : Thread() {} + + /*! \brief Wait for a thread to become ready and sleep in the meantime. + * + */ + void action() override; +}; diff --git a/kernel/thread/scheduler.cc b/kernel/thread/scheduler.cc new file mode 100644 index 0000000..01494f8 --- /dev/null +++ b/kernel/thread/scheduler.cc @@ -0,0 +1,61 @@ +// vim: set noet ts=4 sw=4: + +#include "scheduler.h" + +#include "../arch/core.h" +#include "../debug/assert.h" // IWYU pragma: keep + +Scheduler::Scheduler() {} + +Thread *Scheduler::getNext() { + Thread *next = readylist.dequeue(); + if (next == nullptr) { + next = &idleThread; + } + + assert(next != nullptr && "No thread available!"); + return next; +} + +void Scheduler::schedule() { dispatcher.go(getNext()); } + +void Scheduler::ready(Thread *that) { + assert(that != nullptr && "nullptr pointer not allowed for ready list!"); + + assert(static_cast(&idleThread) != that && + "IdleThread must not be placed in ready list!"); + + readylist.enqueue(*that); +} + +void Scheduler::resume(bool ready) { + Thread *me = dispatcher.active(); + assert(me != nullptr && "Pointer to active thread should never be nullptr"); + + if (true) { + // Be careful, never put the idle thread into the ready list + bool is_idle_thread = static_cast(&idleThread) == me; + + if (ready && readylist.is_empty()) { + return; + } else if (!is_idle_thread) { + if (ready) readylist.enqueue(*me); + } + } + + dispatcher.dispatch(getNext()); +} + +void Scheduler::exit() { + Thread *next = getNext(); + + dispatcher.dispatch(next); +} + +void Scheduler::kill(Thread *that) { + if (dispatcher.active() == that) { + exit(); + } +} + +bool Scheduler::isEmpty() const { return readylist.is_empty(); } diff --git a/kernel/thread/scheduler.h b/kernel/thread/scheduler.h new file mode 100644 index 0000000..675d1bf --- /dev/null +++ b/kernel/thread/scheduler.h @@ -0,0 +1,135 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * + * \brief \ref Scheduler to manage the \ref Thread "threads" + */ + +#pragma once +#include "../object/queue.h" +#include "../types.h" +#include "dispatcher.h" +#include "idlethread.h" +#include "thread.h" + +/*! \brief The scheduler plans the threads' execution order and, from this, + * selects the next thread to be running. + * \ingroup thread + * + * The scheduler manages the ready queue (a private \ref Queue object), + * that is the list of threads that are ready to execute. The scheduler + * arranges threads in a FIFO order, that is, when a thread is set ready, it + * will be appended to the end of the queue, while threads to be executed are + * taken from the front of the queue. + */ +class Scheduler { + /*! \brief a Dispatcher object, providing the low level context switching + * routines. + */ + Dispatcher dispatcher; + + /*! \brief Helper to retrieve next Thread + * \return pointer of next thread + * + */ + Thread* getNext(); + + /*! \brief List of threads, ready to be run + */ + Queue readylist; + + /*! \brief Idle thread + */ + IdleThread idleThread; + + public: + Scheduler(); + + /*! \brief Start scheduling + * + * This method starts the scheduling by removing the first thread from + * the ready queue and activating it. \MPStuBS needs to call this method + * once for every CPU core to dispatch the first thread. + * + */ + void schedule(); + + /*! \brief Include a thread in scheduling decisions. + * + * This method will register a thread for scheduling. It will be appended + * to the ready queue and dispatched once its time has come. + * \param that \ref Thread to be scheduled + * + */ + void ready(Thread* that); + + /*! \brief (Self-)termination of the calling thread. + * + * This method can be used by a thread to exit itself. The calling + * thread will not be appended to the ready queue; a reschedule will be + * issued. + * + */ + void exit(); + + /*! \brief Kills the passed thread + * + * This method is used to kill the \ref Thread `that`. + * For \OOStuBS, it is sufficient to remove `that` from the ready queue + * and, thereby, exclude the thread from scheduling. + * For \MPStuBS, a simple removal is not sufficient, as the thread might + * currently be running on another CPU core. In this case, the thread needs + * to be marked as *dying* (a flag checked by resume prior to enqueuing + * into the ready queue) + */ + /*! + * Note: The thread should be able to kill itself. + * + * + */ + void kill(Thread* that); + + /*! \brief Issue a thread change + * + * This method issues the change of the currently active thread without + * requiring the calling thread to be aware of the other threads. + * Scheduling decisions, i.e. which thread will be run next, are made by + * the scheduler itself with the knowledge of the currently ready threads. + * The currently active thread is appended to the end of the queue; the + * first thread in the queue will be activated (to implement the FIFO + * policy). + * + * \param ready If `false`, the currently active thread will not be + * enqueued for scheduling again. + * + */ + void resume(bool ready = true); + + /*! \brief return the active thread from the dispatcher + */ + Thread* active() const { return dispatcher.active(); } + + /*! \brief Checks whether the ready queue is empty. + * + */ + bool isEmpty() const; +}; + +/*! \brief Pretty print of Thread info + * (optional) + */ +template +T& operator<<(T& out, const Thread* thread) { + if (thread == nullptr) { + out << "(Thread nullptr)"; + } else { + out << "Thread " << thread->id; + } + return out; +} + +template +T& operator<<(T& out, const Thread& thread) { + out << &thread; + return out; +} diff --git a/kernel/thread/thread.cc b/kernel/thread/thread.cc new file mode 100644 index 0000000..b53c678 --- /dev/null +++ b/kernel/thread/thread.cc @@ -0,0 +1,36 @@ +// vim: set noet ts=4 sw=4: + +#include "thread.h" + +#include "../debug/kernelpanic.h" +#include "../interrupt/guard.h" +#include "debug/output.h" + +// counter for ID +static size_t idCounter = 1; + +void Thread::kickoff(uintptr_t param1, uintptr_t param2, uintptr_t param3) { + Thread *thread = reinterpret_cast(param1); + assert(thread != nullptr && "Kickoff got nullptr pointer to Thread"); + (void)param2; // will be used later + (void)param3; // will be used later + // The core must have entered level 1/2 to cause a thread to be scheduled. + Guard::leave(); + + thread->action(); +} + +Thread::Thread() : queue_link(nullptr), id(idCounter++), kill_flag(false) { + void *tos = reinterpret_cast(reserved_stack_space + STACK_SIZE); + prepareContext(tos, context, kickoff, reinterpret_cast(this), 0, + 0); +} + +void Thread::resume(Thread *next) { + assert(next != nullptr && "Pointer to next Thread must not be nullptr!"); + context_switch(&next->context, &context); +} + +void Thread::go() { context_launch(&context); } + +void Thread::action() { kernelpanic("Wrong entry / missing action in Thread"); } diff --git a/kernel/thread/thread.h b/kernel/thread/thread.h new file mode 100644 index 0000000..8149670 --- /dev/null +++ b/kernel/thread/thread.h @@ -0,0 +1,102 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief \ref Thread abstraction required for multithreading + */ + +/*! \defgroup thread Multithreading + * \brief The Multithreading Subsystem + * + * The group Multithreading contains all elements that form the foundation + * of CPU multiplexing. This module's objective is to provide the abstraction + * thread that provides a virtualized CPU for the user's applications. + */ + +#pragma once +#include "../arch/context.h" +#include "../object/queue.h" +#include "../types.h" + +/// Stack size for each thread +constexpr uint32_t STACK_SIZE = 4096; + +/*! \brief The Thread is an object used by the scheduler. + * \ingroup thread + */ +class Thread { + private: + /*! \brief pointer to the next element of the readylist + */ + Thread* queue_link; + + friend class Queue; + friend class Semaphore; + /*! \brief Memory reserved for this threads stack + */ + alignas(16) char reserved_stack_space[STACK_SIZE]; + + protected: + /*! \brief Context of the thread, used for saving and restoring the register + * values when context switching. + */ + Context context; + + /*! \brief The thread's entry point. + * + * For the first activation of a thread, we need a "return address" + * pointing to a function that will take care of calling C++ virtual + * methods (e.g. \ref action()), based on the thread object pointer. + * For this purpose, we use this `kickoff()` function. + * + * \note As this function is never actually called, but only executed by + * returning from the co-routine's initial stack, it may never + * return. Otherwise garbage values from the stack will be interpreted as + * return address and the system might crash. + * + * \param param1 Thread to be started + * \param param2 Second parameter (will be used later) + * \param param3 Third parameter (will be used later) + */ + static void kickoff(uintptr_t param1, uintptr_t param2, uintptr_t param3); + + public: + /*! \brief Unique thread id */ + const size_t id; + + /*! \brief Marker for a dying thread + */ + volatile bool kill_flag; + + /*! \brief Constructor + * Initializes the context using \ref prepareContext with the thread's + * stack space. + * + */ + explicit Thread(); + + /*! \brief Activates the first thread on this CPU. + * + * Calling the method starts the first thread on the calling CPU. + * From then on, \ref Thread::resume() must be used for all subsequent + * context switches. + * + */ + void go(); + + /*! \brief Switches from the currently running thread to the `next` one. + * + * The values currently present in the callee-saved registers will be + * stored in this threads context-structure, the corresponding values + * belonging to `next` thread will be loaded. + * \param next Pointer to the next thread. + * + */ + void resume(Thread* next); + + /*! \brief Method that contains the thread's program code. + * + * Derived classes are meant to override this method to provide + * meaningful code to be run in this thread. + */ + virtual void action() = 0; // XXX: why is this not always pure virtual? +}; diff --git a/kernel/types.h b/kernel/types.h new file mode 100644 index 0000000..8cb7481 --- /dev/null +++ b/kernel/types.h @@ -0,0 +1,67 @@ +/*! \file + * \brief Definition of standard integer types with specified widths and their + * limits + */ + +#pragma once + +// Standard Integer Types +using uint8_t = unsigned char; +using uint16_t = unsigned short; +using uint32_t = unsigned int; +using uint64_t = unsigned long long; +using uintptr_t = unsigned long long; + +using size_t = __SIZE_TYPE__; + +using int8_t = char; +using int16_t = short; +using int32_t = int; +using int64_t = long long; +using intptr_t = long long; + +using ssize_t = long int; + +using ptrdiff_t = __PTRDIFF_TYPE__; + +// Validate typedef size +static_assert(sizeof(int8_t) == (1), "Wrong size for 'int8_t'"); +static_assert(sizeof(int16_t) == (2), "Wrong size for 'int16_t'"); +static_assert(sizeof(int32_t) == (4), "Wrong size for 'int32_t'"); +static_assert(sizeof(int64_t) == (8), "Wrong size for 'int64_t'"); +static_assert(sizeof(intptr_t) == sizeof(void*), "Wrong size for 'intptr_t'"); +static_assert(sizeof(uint8_t) == (1), "Wrong size for 'uint8_t'"); +static_assert(sizeof(uint16_t) == (2), "Wrong size for 'uint16_t'"); +static_assert(sizeof(uint32_t) == (4), "Wrong size for 'uint32_t'"); +static_assert(sizeof(uint64_t) == (8), "Wrong size for 'uint64_t'"); +static_assert(sizeof(uintptr_t) == sizeof(void*), "Wrong size for 'uintptr_t'"); + +// Limits +constexpr int8_t INT8_MIN = (-__INT8_MAX__ - 1); +constexpr int8_t INT8_MAX = (__INT8_MAX__); +constexpr int16_t INT16_MIN = (-__INT16_MAX__ - 1); +constexpr int16_t INT16_MAX = (__INT16_MAX__); +constexpr int32_t INT32_MIN = (-__INT32_MAX__ - 1); +constexpr int32_t INT32_MAX = (__INT32_MAX__); +constexpr int64_t INT64_MIN = (-__INT64_MAX__ - 1); +constexpr int64_t INT64_MAX = (__INT64_MAX__); +constexpr intptr_t INTPTR_MIN = (-__INTPTR_MAX__ - 1); +constexpr intptr_t INTPTR_MAX = (__INTPTR_MAX__); + +constexpr uint8_t UINT8_MAX = (__UINT8_MAX__); +constexpr uint16_t UINT16_MAX = (__UINT16_MAX__); +constexpr uint32_t UINT32_MAX = (__UINT32_MAX__); +constexpr uint64_t UINT64_MAX = (__UINT64_MAX__); +constexpr uintptr_t UINTPTR_MAX = (__UINTPTR_MAX__); + +constexpr ptrdiff_t PTRDIFF_MIN = (-__PTRDIFF_MAX__ - 1); +constexpr ptrdiff_t PTRDIFF_MAX = (__PTRDIFF_MAX__); + +constexpr size_t SIZE_MAX = (__SIZE_MAX__); +constexpr ssize_t SSIZE_MIN = (-__INT32_MAX__ - 1); +constexpr ssize_t SSIZE_MAX = (__INT32_MAX__); + +/// The name of our OS +constexpr char* OS_NAME = + "StuBS" + "mI"; diff --git a/kernel/user/app1/appl.cc b/kernel/user/app1/appl.cc new file mode 100644 index 0000000..99791d8 --- /dev/null +++ b/kernel/user/app1/appl.cc @@ -0,0 +1,42 @@ +// vim: set noet ts=4 sw=4: + +#include "appl.h" + +#include "../../arch/core.h" +#include "../../arch/system.h" +#include "../../debug/output.h" +#include "../../device/textstream.h" +#include "../../interrupt/guard.h" +#include "../../sync/semaphore.h" +#include "../../thread/scheduler.h" +extern Semaphore koutsem; +extern TextStream kout; + +extern Application apps[]; + +void Application::action() { // NOLINT + + // Thread 1 may be an auxiliary thread + unsigned id = 0; + while (&apps[id++] != this); + for (unsigned i = 0;; ++i) { + // Make sure that we can use kout exclusively due to the hardware cursor + // otherwise we'd get a word jumble + koutsem.p(Guard::enter().vault()); + kout.setPos(0U, id); + kout << i; + kout.flush(); + koutsem.v(Guard::enter().vault()); + // XXX: Doing this (the first time) in TASK 16 breaks all scheduling + if (i == 10000) { + if (id % 2 == 1) { + Guard::enter().vault().scheduler.kill(&apps[id - 1]); + } + } + Guard::enter().vault().scheduler.resume(); + if (id > 1) { + Guarded g = Guard::enter(); + g.vault().bellringer.sleep(g.vault(), id * id * 10); + } + } +} diff --git a/kernel/user/app1/appl.h b/kernel/user/app1/appl.h new file mode 100644 index 0000000..a42a90c --- /dev/null +++ b/kernel/user/app1/appl.h @@ -0,0 +1,32 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief Enthält die Klasse Application + */ + +#pragma once +#include "../../thread/thread.h" +#include "../../types.h" + +//! \brief Test application +//! +//! \note Any class derived from Thread defines an application for StuBS. +//! +class Application : public Thread { + // Prevent copies and assignments + Application(const Application&) = delete; + Application& operator=(const Application&) = delete; + + public: + Application(Application&&) = delete; + + /*! \brief Constructor + * + */ + Application() {} + + /*! \brief Contains the application code. + * + */ + void action() override; +}; diff --git a/kernel/user/app2/kappl.cc b/kernel/user/app2/kappl.cc new file mode 100644 index 0000000..b63d956 --- /dev/null +++ b/kernel/user/app2/kappl.cc @@ -0,0 +1,48 @@ +// vim: set noet ts=4 sw=4: + +#include "./kappl.h" + +#include "../../device/textstream.h" +extern TextStream kout; +#include "../../interrupt/guard.h" +extern Semaphore koutsem; + +void KeyboardApplication::action() { // NOLINT + const unsigned line = 10 + 2; + for (unsigned column = 0;; ++column) { + Key key; + { + Guarded g = Guard::enter(); + g.vault().keys_sem.p(g.vault()); + assert(g.vault().keys.consume(key) && "No key but sem returned!"); + } + if (key.valid()) { + if (column >= CGA::COLUMNS - 1) { + column = 0; + koutsem.p(Guard::enter().vault()); + for (unsigned offset = 0; offset < 3; offset++) { + for (unsigned column = 0; column < CGA::COLUMNS; ++column) { + CGA::show(column, line + offset, ' '); + } + } + koutsem.v(Guard::enter().vault()); + } + koutsem.p(Guard::enter().vault()); + kout.setPos(column, line); + kout << static_cast(key.ascii()); + kout.flush(); + koutsem.v(Guard::enter().vault()); + } + for (unsigned offset = 0; offset < 3; offset++) { + { + Guarded g = Guard::enter(); + g.vault().bellringer.sleep(g.vault(), 10); + koutsem.p(g.vault()); + } + kout.setPos(column, line + offset); + kout << static_cast(key.ascii()); + kout.flush(); + koutsem.v(Guard::enter().vault()); + } + } +} diff --git a/kernel/user/app2/kappl.h b/kernel/user/app2/kappl.h new file mode 100644 index 0000000..5e06e74 --- /dev/null +++ b/kernel/user/app2/kappl.h @@ -0,0 +1,26 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief Enthält die Klasse KeyboardApplication + */ + +#pragma once +#include "../../thread/thread.h" +#include "../../types.h" + +/*! \brief Keyboard Application + * + */ +class KeyboardApplication : public Thread { + // Prevent copies and assignments + KeyboardApplication(const KeyboardApplication&) = delete; + KeyboardApplication& operator=(const KeyboardApplication&) = delete; + + public: + KeyboardApplication() {} + + /*! \brief Contains the application code. + * + */ + void action() override; +}; diff --git a/kernel/user/loader.cc b/kernel/user/loader.cc new file mode 100644 index 0000000..6caa263 --- /dev/null +++ b/kernel/user/loader.cc @@ -0,0 +1 @@ +#include "device/textstream.h" diff --git a/kernel/utils/alloc.cc b/kernel/utils/alloc.cc new file mode 100644 index 0000000..4ee0750 --- /dev/null +++ b/kernel/utils/alloc.cc @@ -0,0 +1,15 @@ +#include "./alloc.h" + +#include "../debug/assert.h" + +void *malloc([[maybe_unused]] size_t size) { + assert(!"Memory allocation not supported"); + return nullptr; +} +void *calloc([[maybe_unused]] size_t nmemb, [[maybe_unused]] size_t size) { + assert(!"Memory allocation not supported"); + return nullptr; +} +void free([[maybe_unused]] void *ptr) { + assert(!"Memory allocation not supported"); +} diff --git a/kernel/utils/alloc.h b/kernel/utils/alloc.h new file mode 100644 index 0000000..a752e97 --- /dev/null +++ b/kernel/utils/alloc.h @@ -0,0 +1,36 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief C-style dynamic memory allocation interface + */ + +#pragma once + +#include "../types.h" + +/*! \brief Allocate a memory block + * The memory is not initialized. + * + * \param size Requested size of memory in bytes. + * \return Pointer to memory or `nullptr` on error (no memory available) or if + * size was zero. + * \opt Implement method + */ +extern "C" void *malloc(size_t size); + +/*! \brief Free an allocated memory block + * + * \param ptr Pointer to an previously allocated memory block. + * \opt Implement method + */ +extern "C" void free(void *ptr); + +/*! \brief Allocate memory for an array of elements + * The memory is set to zero. + * + * \param nmemb Number of elements + * \param size Size of an element in bytes + * \return pointer to the allocated memory or `nullptr` if the request fails + * \opt Implement method + */ +extern "C" void *calloc(size_t nmemb, size_t size); diff --git a/kernel/utils/math.h b/kernel/utils/math.h new file mode 100644 index 0000000..9ca6b36 --- /dev/null +++ b/kernel/utils/math.h @@ -0,0 +1,27 @@ +// vim: set noet ts=4 sw=4: + +/*! \file + * \brief General purpose \ref Math "math functions" + */ + +#pragma once +#include "types.h" + +/*! \brief Basic math helper functions + */ +namespace Math { +template +T abs(T a) { + return (a >= 0 ? a : -a); +} + +template +T min(T a, T b) { + return a > b ? b : a; +} + +template +T max(T a, T b) { + return a > b ? a : b; +} +} // namespace Math diff --git a/kernel/utils/png.cc b/kernel/utils/png.cc new file mode 100644 index 0000000..2bac70a --- /dev/null +++ b/kernel/utils/png.cc @@ -0,0 +1,1215 @@ +/*! \file + * \brief contains a PNG library + * + * The PNG library 'uPNG' was written by Sean Middleditch and Lode Vandevenne + * and modified for StuBS by Bernhard Heinloth. + * + * \see https://github.com/elanthis/upng + * + * uPNG -- derived from LodePNG version 20100808 + * + * Copyright (c) 2005-2010 Lode Vandevenne + * Copyright (c) 2010 Sean Middleditch + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not + *be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + */ +#include "./png.h" + +#include "./alloc.h" +#include "./string.h" + +#define MAKE_BYTE(b) ((b) & 0xFF) +#define MAKE_DWORD(a, b, c, d) \ + ((MAKE_BYTE(a) << 24) | (MAKE_BYTE(b) << 16) | (MAKE_BYTE(c) << 8) | \ + MAKE_BYTE(d)) +#define MAKE_DWORD_PTR(p) MAKE_DWORD((p)[0], (p)[1], (p)[2], (p)[3]) + +#define CHUNK_IHDR MAKE_DWORD('I', 'H', 'D', 'R') +#define CHUNK_IDAT MAKE_DWORD('I', 'D', 'A', 'T') +#define CHUNK_IEND MAKE_DWORD('I', 'E', 'N', 'D') + +#define FIRST_LENGTH_CODE_INDEX 257 +#define LAST_LENGTH_CODE_INDEX 285 + +#define NUM_DEFLATE_CODE_SYMBOLS \ + 288 // 256 literals, the end code, some length codes, and 2 unused codes +#define NUM_DISTANCE_SYMBOLS \ + 32 // the distance codes have their own symbols, 30 used, 2 unused +#define NUM_CODE_LENGTH_CODES 19 // the code length codes. +// 0-15: code lengths, +// 16: copy previous 3-6 times, +// 17: 3-10 zeros, +// 18: 11-138 zeros +#define MAX_SYMBOLS 288 // largest number of symbols used by any tree type + +#define DEFLATE_CODE_BITLEN 15 +#define DISTANCE_BITLEN 15 +#define CODE_LENGTH_BITLEN 7 +#define MAX_BIT_LENGTH 15 // largest bitlen used by any tree type + +#define DEFLATE_CODE_BUFFER_SIZE (NUM_DEFLATE_CODE_SYMBOLS * 2) +#define DISTANCE_BUFFER_SIZE (NUM_DISTANCE_SYMBOLS * 2) +#define CODE_LENGTH_BUFFER_SIZE (NUM_DISTANCE_SYMBOLS * 2) + +#define SET_ERROR(code) \ + do { \ + error = (code); \ + error_line = __LINE__; \ + } while (0) + +#define chunk_length(chunk) MAKE_DWORD_PTR(chunk) +#define chunk_type(chunk) MAKE_DWORD_PTR((chunk) + 4) +#define chunk_critical(chunk) (((chunk)[4] & 32) == 0) + +// the base lengths represented by codes 257-285 +static const unsigned LENGTH_BASE[29] = { + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, + 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258}; + +// the extra bits used by codes 257-285 (added to base length) +static const unsigned LENGTH_EXTRA[29] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, + 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, + 4, 4, 4, 4, 5, 5, 5, 5, 0}; + +// the base backwards distances (the bits of distance codes appear after length +// codes and use their own huffman tree) +static const unsigned DISTANCE_BASE[30] = { + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, + 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, + 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577}; + +// the extra bits of backwards distances (added to base) +static const unsigned DISTANCE_EXTRA[30] = { + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, + 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; + +// the order in which "code length alphabet code lengths" are stored, +// out of this the huffman tree of the dynamic huffman tree lengths is generated +static const unsigned CLCL[NUM_CODE_LENGTH_CODES] = { + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + +static unsigned FIXED_DEFLATE_CODE_TREE[NUM_DEFLATE_CODE_SYMBOLS * 2] = { + 289, 370, 290, 307, 546, 291, 561, 292, 293, 300, 294, 297, 295, 296, 0, + 1, 2, 3, 298, 299, 4, 5, 6, 7, 301, 304, 302, 303, 8, 9, + 10, 11, 305, 306, 12, 13, 14, 15, 308, 339, 309, 324, 310, 317, 311, + 314, 312, 313, 16, 17, 18, 19, 315, 316, 20, 21, 22, 23, 318, 321, + 319, 320, 24, 25, 26, 27, 322, 323, 28, 29, 30, 31, 325, 332, 326, + 329, 327, 328, 32, 33, 34, 35, 330, 331, 36, 37, 38, 39, 333, 336, + 334, 335, 40, 41, 42, 43, 337, 338, 44, 45, 46, 47, 340, 355, 341, + 348, 342, 345, 343, 344, 48, 49, 50, 51, 346, 347, 52, 53, 54, 55, + 349, 352, 350, 351, 56, 57, 58, 59, 353, 354, 60, 61, 62, 63, 356, + 363, 357, 360, 358, 359, 64, 65, 66, 67, 361, 362, 68, 69, 70, 71, + 364, 367, 365, 366, 72, 73, 74, 75, 368, 369, 76, 77, 78, 79, 371, + 434, 372, 403, 373, 388, 374, 381, 375, 378, 376, 377, 80, 81, 82, 83, + 379, 380, 84, 85, 86, 87, 382, 385, 383, 384, 88, 89, 90, 91, 386, + 387, 92, 93, 94, 95, 389, 396, 390, 393, 391, 392, 96, 97, 98, 99, + 394, 395, 100, 101, 102, 103, 397, 400, 398, 399, 104, 105, 106, 107, 401, + 402, 108, 109, 110, 111, 404, 419, 405, 412, 406, 409, 407, 408, 112, 113, + 114, 115, 410, 411, 116, 117, 118, 119, 413, 416, 414, 415, 120, 121, 122, + 123, 417, 418, 124, 125, 126, 127, 420, 427, 421, 424, 422, 423, 128, 129, + 130, 131, 425, 426, 132, 133, 134, 135, 428, 431, 429, 430, 136, 137, 138, + 139, 432, 433, 140, 141, 142, 143, 435, 483, 436, 452, 568, 437, 438, 445, + 439, 442, 440, 441, 144, 145, 146, 147, 443, 444, 148, 149, 150, 151, 446, + 449, 447, 448, 152, 153, 154, 155, 450, 451, 156, 157, 158, 159, 453, 468, + 454, 461, 455, 458, 456, 457, 160, 161, 162, 163, 459, 460, 164, 165, 166, + 167, 462, 465, 463, 464, 168, 169, 170, 171, 466, 467, 172, 173, 174, 175, + 469, 476, 470, 473, 471, 472, 176, 177, 178, 179, 474, 475, 180, 181, 182, + 183, 477, 480, 478, 479, 184, 185, 186, 187, 481, 482, 188, 189, 190, 191, + 484, 515, 485, 500, 486, 493, 487, 490, 488, 489, 192, 193, 194, 195, 491, + 492, 196, 197, 198, 199, 494, 497, 495, 496, 200, 201, 202, 203, 498, 499, + 204, 205, 206, 207, 501, 508, 502, 505, 503, 504, 208, 209, 210, 211, 506, + 507, 212, 213, 214, 215, 509, 512, 510, 511, 216, 217, 218, 219, 513, 514, + 220, 221, 222, 223, 516, 531, 517, 524, 518, 521, 519, 520, 224, 225, 226, + 227, 522, 523, 228, 229, 230, 231, 525, 528, 526, 527, 232, 233, 234, 235, + 529, 530, 236, 237, 238, 239, 532, 539, 533, 536, 534, 535, 240, 241, 242, + 243, 537, 538, 244, 245, 246, 247, 540, 543, 541, 542, 248, 249, 250, 251, + 544, 545, 252, 253, 254, 255, 547, 554, 548, 551, 549, 550, 256, 257, 258, + 259, 552, 553, 260, 261, 262, 263, 555, 558, 556, 557, 264, 265, 266, 267, + 559, 560, 268, 269, 270, 271, 562, 565, 563, 564, 272, 273, 274, 275, 566, + 567, 276, 277, 278, 279, 569, 572, 570, 571, 280, 281, 282, 283, 573, 574, + 284, 285, 286, 287, 0, 0}; + +static unsigned FIXED_DISTANCE_TREE[NUM_DISTANCE_SYMBOLS * 2] = { + 33, 48, 34, 41, 35, 38, 36, 37, 0, 1, 2, 3, 39, 40, 4, 5, + 6, 7, 42, 45, 43, 44, 8, 9, 10, 11, 46, 47, 12, 13, 14, 15, + 49, 56, 50, 53, 51, 52, 16, 17, 18, 19, 54, 55, 20, 21, 22, 23, + 57, 60, 58, 59, 24, 25, 26, 27, 61, 62, 28, 29, 30, 31, 0, 0}; + +static unsigned char read_bit(unsigned long *bitpointer, + const unsigned char *bitstream) { + unsigned char result = static_cast( + (bitstream[(*bitpointer) >> 3] >> ((*bitpointer) & 0x7)) & 1); + (*bitpointer)++; + return result; +} + +static unsigned read_bits(unsigned long *bitpointer, + const unsigned char *bitstream, unsigned long nbits) { + unsigned result = 0; + for (unsigned i = 0; i < nbits; i++) { + result |= (static_cast(read_bit(bitpointer, bitstream))) << i; + } + return result; +} + +// Ignore stack usage warnings in GCC for huffman +#pragma GCC diagnostic push +#if !defined(__clang__) +#pragma GCC diagnostic ignored "-Wstack-usage=" +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#endif + +// the buffer must be numcodes*2 in size! +void PNG::huffman_tree_init(struct huffman_tree *tree, unsigned *buffer, + unsigned numcodes, unsigned maxbitlen) { + tree->tree2d = buffer; + + tree->numcodes = numcodes; + tree->maxbitlen = maxbitlen; +} + +// given the code lengths (as stored in the PNG file), generate the tree as +// defined by Deflate. +// maxbitlen is the maximum bits that a code in the tree can have. return value +// is error. +void PNG::huffman_tree_create_lengths(struct huffman_tree *tree, + const unsigned *bitlen) { + unsigned tree1d[MAX_SYMBOLS]; + unsigned blcount[MAX_BIT_LENGTH]; + unsigned nextcode[MAX_BIT_LENGTH + 1]; + unsigned nodefilled = 0; // up to which node it is filled + unsigned treepos = 0; // position in the tree (1 of the numcodes columns) + + // initialize local vectors + memset(blcount, 0, sizeof(blcount)); + memset(nextcode, 0, sizeof(nextcode)); + + // step 1: count number of instances of each code length + for (unsigned bits = 0; bits < tree->numcodes; bits++) { + blcount[bitlen[bits]]++; + } + + // step 2: generate the nextcode values + for (unsigned bits = 1; bits <= tree->maxbitlen; bits++) { + nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1]) << 1; + } + + // step 3: generate all the codes + for (unsigned n = 0; n < tree->numcodes; n++) { + if (bitlen[n] != 0) { + tree1d[n] = nextcode[bitlen[n]]++; + } + } + + /* convert tree1d[] to tree2d[][]. In the 2D array, a value of 32767 means + * uninited, a value >= numcodes is an address to another bit, a value < + * numcodes is a code. The 2 rows are the 2 possible bit values (0 or 1), + * there are as many columns as codes - 1 + * a good huffmann tree has N * 2 - 1 nodes, of which N - 1 are internal + * nodes. Here, the internal nodes are stored (what their 0 and 1 option + * point to). There is only memory for such good tree currently, if there + * are more nodes (due to too long length codes), error 55 will happen + */ + for (unsigned n = 0; n < tree->numcodes * 2; n++) { + tree->tree2d[n] = + 32767; // 32767 here means the tree2d isn't filled there yet + } + + for (unsigned n = 0; n < tree->numcodes; n++) { // the codes + for (unsigned i = 0; i < bitlen[n]; i++) { // the bits for this code + unsigned char bit = static_cast( + (tree1d[n] >> (bitlen[n] - i - 1)) & 1); + // check if oversubscribed + if (treepos > tree->numcodes - 2) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + if (tree->tree2d[2 * treepos + bit] == + 32767) { // not yet filled in + if (i + 1 == bitlen[n]) { // last bit + tree->tree2d[2 * treepos + bit] = + n; // put the current code in it + treepos = 0; + } else { // put address of the next step in here, + // first that address has to be found of course (it's + // just nodefilled + 1)... + nodefilled++; + tree->tree2d[2 * treepos + bit] = + nodefilled + tree->numcodes; // addresses encoded with + // numcodes added to it + treepos = nodefilled; + } + } else { + treepos = tree->tree2d[2 * treepos + bit] - tree->numcodes; + } + } + } + + for (unsigned n = 0; n < tree->numcodes * 2; n++) { + if (tree->tree2d[n] == 32767) { + tree->tree2d[n] = 0; // remove possible remaining 32767's + } + } +} + +unsigned PNG::huffman_decode_symbol(const unsigned char *in, unsigned long *bp, + const huffman_tree *codetree, + unsigned long inlength) { + unsigned treepos = 0; + while (true) { + // error: end of input memory reached without endcode + if (((*bp) & 0x07) == 0 && ((*bp) >> 3) > inlength) { + SET_ERROR(PNG_EMALFORMED); + return 0; + } + + unsigned char bit = read_bit(bp, in); + + unsigned ct = codetree->tree2d[(treepos << 1) | bit]; + if (ct < codetree->numcodes) { + return ct; + } + + treepos = ct - codetree->numcodes; + if (treepos >= codetree->numcodes) { + SET_ERROR(PNG_EMALFORMED); + return 0; + } + } +} + +// get the tree of a deflated block with dynamic tree, the tree itself is also +// Huffman compressed with a known tree +void PNG::get_tree_inflate_dynamic(struct huffman_tree *codetree, + struct huffman_tree *codetreeD, + struct huffman_tree *codelengthcodetree, + const unsigned char *in, unsigned long *bp, + unsigned long inlength) { + unsigned codelengthcode[NUM_CODE_LENGTH_CODES]; + unsigned bitlen[NUM_DEFLATE_CODE_SYMBOLS]; + unsigned bitlenD[NUM_DISTANCE_SYMBOLS]; + + // make sure that length values that aren't filled in will be 0, or a wrong + // tree will be generated C-code note: use no "return" between ctor and dtor + // of an uivector! + if ((*bp) >> 3 >= inlength - 2) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + // clear bitlen arrays + memset(bitlen, 0, sizeof(bitlen)); + memset(bitlenD, 0, sizeof(bitlenD)); + + // the bit pointer is or will go past the memory + // number of literal/length codes + 257. Unlike the spec, the value 257 is + // added to it here already + unsigned hlit = read_bits(bp, in, 5) + 257; + // number of distance codes. Unlike the spec, the value 1 is added to it + // here already + unsigned hdist = read_bits(bp, in, 5) + 1; + // number of code length codes. Unlike the spec, the value 4 is added to it + // here already + unsigned hclen = read_bits(bp, in, 4) + 4; + + for (unsigned i = 0; i < NUM_CODE_LENGTH_CODES; i++) { + if (i < hclen) { + codelengthcode[CLCL[i]] = read_bits(bp, in, 3); + } else { + codelengthcode[CLCL[i]] = 0; // if not, it must stay 0 + } + } + + huffman_tree_create_lengths(codelengthcodetree, codelengthcode); + + // bail now if we encountered an error earlier + if (error != PNG_EOK) { + return; + } + + // now we can use this tree to read the lengths for the tree that this + // function will return + unsigned i = 0; + // i is the current symbol we're reading in the part that contains the code + // lengths of lit/len codes and dist codes + while (i < hlit + hdist) { + unsigned code = + huffman_decode_symbol(in, bp, codelengthcodetree, inlength); + if (error != PNG_EOK) { + break; + } + + if (code <= 15) { // a length code + if (i < hlit) { + bitlen[i] = code; + } else { + bitlenD[i - hlit] = code; + } + i++; + } else if (code == 16) { // repeat previous + unsigned replength = + 3; // read in the 2 bits that indicate repeat length (3-6) + unsigned value; // set value to the previous code + + if ((*bp) >> 3 >= inlength) { + SET_ERROR(PNG_EMALFORMED); + break; + } + // error, bit pointer jumps past memory + replength += read_bits(bp, in, 2); + + if ((i - 1) < hlit) { + value = bitlen[i - 1]; + } else { + value = bitlenD[i - hlit - 1]; + } + + // repeat this value in the next lengths + for (unsigned n = 0; n < replength; n++) { + // i is larger than the amount of codes + if (i >= hlit + hdist) { + SET_ERROR(PNG_EMALFORMED); + break; + } + + if (i < hlit) { + bitlen[i] = value; + } else { + bitlenD[i - hlit] = value; + } + i++; + } + } else if (code == 17) { // repeat "0" 3-10 times + unsigned replength = + 3; // read in the bits that indicate repeat length + if ((*bp) >> 3 >= inlength) { + SET_ERROR(PNG_EMALFORMED); + break; + } + + // error, bit pointer jumps past memory + replength += read_bits(bp, in, 3); + + // repeat this value in the next lengths + for (unsigned n = 0; n < replength; n++) { + // error: i is larger than the amount of codes + if (i >= hlit + hdist) { + SET_ERROR(PNG_EMALFORMED); + break; + } + + if (i < hlit) { + bitlen[i] = 0; + } else { + bitlenD[i - hlit] = 0; + } + i++; + } + } else if (code == 18) { // repeat "0" 11-138 times + unsigned replength = + 11; // read in the bits that indicate repeat length + // error, bit pointer jumps past memory + if ((*bp) >> 3 >= inlength) { + SET_ERROR(PNG_EMALFORMED); + break; + } + + replength += read_bits(bp, in, 7); + + // repeat this value in the next lengths + for (unsigned n = 0; n < replength; n++) { + // i is larger than the amount of codes + if (i >= hlit + hdist) { + SET_ERROR(PNG_EMALFORMED); + break; + } + if (i < hlit) { + bitlen[i] = 0; + } else { + bitlenD[i - hlit] = 0; + } + i++; + } + } else { + // somehow an unexisting code appeared. This can never happen. + SET_ERROR(PNG_EMALFORMED); + break; + } + } + + if (error == PNG_EOK && bitlen[256] == 0) { + SET_ERROR(PNG_EMALFORMED); + } + + // the length of the end code 256 must be larger than 0 + // now we've finally got hlit and hdist, so generate the code trees, and the + // function is done + if (error == PNG_EOK) { + huffman_tree_create_lengths(codetree, bitlen); + } + if (error == PNG_EOK) { + huffman_tree_create_lengths(codetreeD, bitlenD); + } +} + +// inflate a block with dynamic of fixed Huffman tree +void PNG::inflate_huffman(unsigned char *out, unsigned long outsize, + const unsigned char *in, unsigned long *bp, + unsigned long *pos, unsigned long inlength, + unsigned btype) { + unsigned codetree_buffer[DEFLATE_CODE_BUFFER_SIZE]; + unsigned codetreeD_buffer[DISTANCE_BUFFER_SIZE]; + unsigned done = 0; + + struct huffman_tree codetree; + struct huffman_tree codetreeD; + + if (btype == 1) { + // fixed trees + huffman_tree_init(&codetree, + reinterpret_cast(FIXED_DEFLATE_CODE_TREE), + NUM_DEFLATE_CODE_SYMBOLS, DEFLATE_CODE_BITLEN); + huffman_tree_init(&codetreeD, + reinterpret_cast(FIXED_DISTANCE_TREE), + NUM_DISTANCE_SYMBOLS, DISTANCE_BITLEN); + } else if (btype == 2) { + // dynamic trees + unsigned codelengthcodetree_buffer[CODE_LENGTH_BUFFER_SIZE]; + huffman_tree codelengthcodetree; + + huffman_tree_init(&codetree, codetree_buffer, NUM_DEFLATE_CODE_SYMBOLS, + DEFLATE_CODE_BITLEN); + huffman_tree_init(&codetreeD, codetreeD_buffer, NUM_DISTANCE_SYMBOLS, + DISTANCE_BITLEN); + huffman_tree_init(&codelengthcodetree, codelengthcodetree_buffer, + NUM_CODE_LENGTH_CODES, CODE_LENGTH_BITLEN); + get_tree_inflate_dynamic(&codetree, &codetreeD, &codelengthcodetree, in, + bp, inlength); + } + + while (done == 0) { + unsigned code = huffman_decode_symbol(in, bp, &codetree, inlength); + if (error != PNG_EOK) { + return; + } + + if (code == 256) { + // end code + done = 1; + } else if (code <= 255) { + // literal symbol + if ((*pos) >= outsize) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + // store output + out[(*pos)++] = static_cast(code); + } else if (code >= FIRST_LENGTH_CODE_INDEX && + code <= LAST_LENGTH_CODE_INDEX) { // length code + // part 1: get length base + unsigned long length = LENGTH_BASE[code - FIRST_LENGTH_CODE_INDEX]; + + // part 2: get extra bits and add the value of that to length + unsigned long numextrabits = + LENGTH_EXTRA[code - FIRST_LENGTH_CODE_INDEX]; + + // error, bit pointer will jump past memory + if (((*bp) >> 3) >= inlength) { + SET_ERROR(PNG_EMALFORMED); + return; + } + length += read_bits(bp, in, numextrabits); + + // part 3: get distance code + unsigned codeD = + huffman_decode_symbol(in, bp, &codetreeD, inlength); + if (error != PNG_EOK) { + return; + } + + // invalid distance code (30-31 are never used) + if (codeD > 29) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + unsigned distance = DISTANCE_BASE[codeD]; + + // part 4: get extra bits from distance + unsigned numextrabitsD = DISTANCE_EXTRA[codeD]; + + // error, bit pointer will jump past memory + if (((*bp) >> 3) >= inlength) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + distance += read_bits(bp, in, numextrabitsD); + + // part 5: fill in all the out[n] values based on the length and + // dist + unsigned long start = (*pos); + unsigned long backward = start - distance; + + if ((*pos) + length >= outsize) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + for (unsigned long forward = 0; forward < length; forward++) { + out[(*pos)++] = out[backward]; + backward++; + + if (backward >= start) { + backward = start - distance; + } + } + } + } +} +#pragma GCC diagnostic pop + +void PNG::inflate_uncompressed(unsigned char *out, unsigned long outsize, + const unsigned char *in, unsigned long *bp, + unsigned long *pos, unsigned long inlength) { + // go to first boundary of byte + while (((*bp) & 0x7) != 0) { + (*bp)++; + } + unsigned long p = (*bp) / 8; // byte position + + // read len (2 bytes) and nlen (2 bytes) + if (p >= inlength - 4) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + unsigned len = in[p] + 256 * in[p + 1]; + p += 2; + unsigned nlen = in[p] + 256 * in[p + 1]; + p += 2; + + // check if 16-bit nlen is really the one's complement of len + if (len + nlen != 65535) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + if ((*pos) + len >= outsize) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + // read the literal data: len bytes are now stored in the out buffer + if (p + len > inlength) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + for (unsigned n = 0; n < len; n++) { + out[(*pos)++] = in[p++]; + } + + (*bp) = p * 8; +} + +enum PNG::error PNG::uz_inflate_data(unsigned char *out, unsigned long outsize, + const unsigned char *in, + unsigned long insize, + unsigned long inpos) { + // bit pointer in the "in" data, current byte is bp >> 3, current bit is bp + // & 0x7 (from lsb to msb of the byte) + unsigned long bp = 0; + // byte position in the out buffer + unsigned long pos = 0; + + unsigned done = 0; + + while (done == 0) { + unsigned btype; + + // ensure next bit doesn't point past the end of the buffer + if ((bp >> 3) >= insize) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // read block control bits + done = read_bit(&bp, &in[inpos]); + btype = read_bit(&bp, &in[inpos]) | (read_bit(&bp, &in[inpos]) << 1); + + // process control type appropriateyly + if (btype == 0) { + inflate_uncompressed(out, outsize, &in[inpos], &bp, &pos, + insize); // no compression + } else if (btype < 3) { + inflate_huffman(out, outsize, &in[inpos], &bp, &pos, insize, + btype); // compression, btype 01 or 10 + } else { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // stop if an error has occured + if (error != PNG_EOK) { + return error; + } + } + + return error; +} + +enum PNG::error PNG::uz_inflate(unsigned char *out, unsigned long outsize, + const unsigned char *in, unsigned long insize) { + // we require two bytes for the zlib data header + if (insize < 2) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is + // supposed to be made that way + if ((in[0] * 256 + in[1]) % 31 != 0) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // error: only compression method 8: inflate with sliding window of 32k is + // supported by the PNG spec + if ((in[0] & 15) != 8 || ((in[0] >> 4) & 15) > 7) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // the specification of PNG says about the zlib stream: "The additional + // flags shall not specify a preset dictionary." + if (((in[1] >> 5) & 1) != 0) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // create output buffer + uz_inflate_data(out, outsize, in, insize, 2); + + return error; +} + +// Paeth predicter, used by PNG filter type 4 +static int paeth_predictor(int a, int b, int c) { + int p = a + b - c; + int pa = p > a ? p - a : a - p; + int pb = p > b ? p - b : b - p; + int pc = p > c ? p - c : c - p; + + if (pa <= pb && pa <= pc) { + return a; + } else if (pb <= pc) { + return b; + } else { + return c; + } +} + +void PNG::unfilter_scanline(unsigned char *recon, const unsigned char *scanline, + const unsigned char *precon, + unsigned long bytewidth, unsigned char filterType, + unsigned long length) { + /* + For PNG filter method 0 + unfilter a PNG image scanline by scanline. when the pixels are smaller + than 1 byte, the filter works byte per byte (bytewidth = 1) precon is the + previous unfiltered scanline, recon the result, scanline the current one + the incoming scanlines do NOT include the filtertype byte, that one is + given in the parameter filterType instead recon and scanline MAY be the + same memory address! precon must be disjoint. + */ + + switch (filterType) { + case 0: + for (unsigned long i = 0; i < length; i++) { + recon[i] = scanline[i]; + } + break; + + case 1: + for (unsigned long i = 0; i < bytewidth; i++) { + recon[i] = scanline[i]; + } + for (unsigned long i = bytewidth; i < length; i++) { + recon[i] = scanline[i] + recon[i - bytewidth]; + } + break; + + case 2: + for (unsigned long i = 0; i < length; i++) { + recon[i] = scanline[i] + (precon == nullptr ? 0 : precon[i]); + } + break; + + case 3: + for (unsigned long i = 0; i < bytewidth; i++) { + recon[i] = + scanline[i] + (precon == nullptr ? 0 : (precon[i] / 2)); + } + for (unsigned long i = bytewidth; i < length; i++) { + recon[i] = + scanline[i] + ((recon[i - bytewidth] + + (precon == nullptr ? 0 : precon[i])) / + 2); + } + break; + + case 4: + for (unsigned long i = 0; i < bytewidth; i++) { + recon[i] = static_cast( + scanline[i] + + (precon == nullptr ? 0 : paeth_predictor(0, precon[i], 0))); + } + for (unsigned long i = bytewidth; i < length; i++) { + recon[i] = static_cast( + scanline[i] + + (precon == nullptr + ? paeth_predictor(recon[i - bytewidth], 0, 0) + : paeth_predictor(recon[i - bytewidth], precon[i], + precon[i - bytewidth]))); + } + break; + + default: + SET_ERROR(PNG_EMALFORMED); + break; + } +} + +void PNG::unfilter(unsigned char *out, const unsigned char *in, unsigned w, + unsigned h, unsigned bpp) { + /* + For PNG filter method 0 + this function unfilters a single image (e.g. without interlacing this is + called once, with Adam7 it's called 7 times) out must have enough bytes + allocated already, in must have the scanlines + 1 filtertype byte per + scanline w and h are image dimensions or dimensions of reduced image, bpp + is bpp per pixel in and out are allowed to be the same memory address! + */ + + unsigned y; + unsigned char *prevline = 0; + + // bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per + // pixel otherwise + unsigned long bytewidth = (bpp + 7) / 8; + unsigned long linebytes = (w * bpp + 7) / 8; + + for (y = 0; y < h; y++) { + unsigned long outindex = linebytes * y; + unsigned long inindex = + (1 + linebytes) * y; // the extra filterbyte added to each row + unsigned char filterType = in[inindex]; + + unfilter_scanline(&out[outindex], &in[inindex + 1], prevline, bytewidth, + filterType, linebytes); + if (error != PNG_EOK) { + return; + } + + prevline = &out[outindex]; + } +} + +void PNG::remove_padding_bits(unsigned char *out, const unsigned char *in, + unsigned long olinebits, unsigned long ilinebits, + unsigned h) { + /* + After filtering there are still padding bpp if scanlines have non + multiple of 8 bit amounts. They need to be removed (except at last + scanline of (Adam7-reduced) image) before working with pure image buffers + for the Adam7 code, the color convert code and the output to the user. in + and out are allowed to be the same buffer, in may also be higher but + still overlapping; in must have >= ilinebits*h bpp, out must have >= + olinebits*h bpp, olinebits must be <= ilinebits also used to move bpp + after earlier such operations happened, e.g. in a sequence of reduced + images from Adam7 only useful if (ilinebits - olinebits) is a value in + the range 1..7 + */ + unsigned long diff = ilinebits - olinebits; + unsigned long obp = 0; + unsigned long ibp = 0; // bit pointers + for (unsigned y = 0; y < h; y++) { + for (unsigned long x = 0; x < olinebits; x++) { + unsigned char bit = static_cast( + (in[(ibp) >> 3] >> (7 - ((ibp) & 0x7))) & 1); + ibp++; + + if (bit == 0) { + out[(obp) >> 3] &= + static_cast(~(1 << (7 - ((obp) & 0x7)))); + } else { + out[(obp) >> 3] |= (1 << (7 - ((obp) & 0x7))); + } + ++obp; + } + ibp += diff; + } +} + +// out must be buffer big enough to contain full image, and in must contain the +// full decompressed data from the IDAT chunks +void PNG::post_process_scanlines(unsigned char *out, unsigned char *in, + const PNG *info_png) { + unsigned bpp = info_png->get_bpp(); + unsigned w = info_png->width; + unsigned h = info_png->height; + + if (bpp == 0) { + SET_ERROR(PNG_EMALFORMED); + return; + } + + if (bpp < 8 && w * bpp != ((w * bpp + 7) / 8) * 8) { + unfilter(in, in, w, h, bpp); + if (error != PNG_EOK) { + return; + } + remove_padding_bits(out, in, w * bpp, ((w * bpp + 7) / 8) * 8, h); + } else { + unfilter(out, in, w, h, bpp); // we can immediatly filter into the out + // buffer, no other steps needed + } +} + +enum PNG::format PNG::determine_format() { + switch (color_type) { + case COLOR_LUM: + switch (color_depth) { + case 1: + return LUMINANCE1; + case 2: + return LUMINANCE2; + case 4: + return LUMINANCE4; + case 8: + return LUMINANCE8; + default: + return BADFORMAT; + } + case COLOR_RGB: + switch (color_depth) { + case 8: + return RGB8; + case 16: + return RGB16; + default: + return BADFORMAT; + } + case COLOR_LUMA: + switch (color_depth) { + case 1: + return LUMINANCE_ALPHA1; + case 2: + return LUMINANCE_ALPHA2; + case 4: + return LUMINANCE_ALPHA4; + case 8: + return LUMINANCE_ALPHA8; + default: + return BADFORMAT; + } + case COLOR_RGBA: + switch (color_depth) { + case 8: + return RGBA8; + case 16: + return RGBA16; + default: + return BADFORMAT; + } + default: + return BADFORMAT; + } +} + +void PNG::free_source() { + if (source.owning != 0) { + free(reinterpret_cast( + const_cast(source.buffer))); + } + + source.buffer = nullptr; + source.size = 0; + source.owning = 0; +} + +// read the information from the header and store it in theupng_Info. return +// value is error +enum PNG::error PNG::header() { + // if we have an error state, bail now + if (error != PNG_EOK) { + return error; + } + + // if the state is not NEW (meaning we are ready to parse the header), stop + // now + if (state != STATE_NEW) { + return error; + } + + /* minimum length of a valid PNG file is 29 bytes + * FIXME: verify this against the specification, or + * better against the actual code below */ + if (source.size < 29) { + SET_ERROR(PNG_ENOTPNG); + return error; + } + + // check that PNG header matches expected value + if (source.buffer[0] != 137 || source.buffer[1] != 80 || + source.buffer[2] != 78 || source.buffer[3] != 71 || + source.buffer[4] != 13 || source.buffer[5] != 10 || + source.buffer[6] != 26 || source.buffer[7] != 10) { + SET_ERROR(PNG_ENOTPNG); + return error; + } + + // check that the first chunk is the IHDR chunk + if (MAKE_DWORD_PTR(source.buffer + 12) != CHUNK_IHDR) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // read the values given in the header + width = MAKE_DWORD_PTR(source.buffer + 16); + height = MAKE_DWORD_PTR(source.buffer + 20); + color_depth = source.buffer[24]; + color_type = static_cast(source.buffer[25]); + + // determine our color format + format = determine_format(); + if (format == BADFORMAT) { + SET_ERROR(PNG_EUNFORMAT); + return error; + } + + // check that the compression method (byte 27) is 0 (only allowed value in + // spec) + if (source.buffer[26] != 0) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // check that the compression method (byte 27) is 0 (only allowed value in + // spec) + if (source.buffer[27] != 0) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // check that the compression method (byte 27) is 0 (spec allows 1, but uPNG + // does not support it) + if (source.buffer[28] != 0) { + SET_ERROR(PNG_EUNINTERLACED); + return error; + } + + state = STATE_HEADER; + return error; +} + +// read a PNG, the result will be in the same color type as the PNG (hence +// "generic") +enum PNG::error PNG::decode() { + unsigned long compressed_size = 0; + unsigned long compressed_index = 0; + + // if we have an error state, bail now + if (error != PNG_EOK) { + return error; + } else if (state == STATE_DECODED) { + return PNG_EOK; + } + + // parse the main header, if necessary + header(); + if (error != PNG_EOK) { + return error; + } + + // if the state is not HEADER (meaning we are ready to decode the image), + // stop now + if (state != STATE_HEADER) { + return error; + } + + // release old result, if any + if (buffer != 0) { + free(buffer); + buffer = 0; + size = 0; + } + + // first byte of the first chunk after the header + const unsigned char *chunk = source.buffer + 33; + + /* scan through the chunks, finding the size of all IDAT chunks, and also + * verify general well-formed-ness */ + while (chunk < source.buffer + source.size) { + // make sure chunk header is not larger than the total compressed + if (static_cast(chunk - source.buffer + 12) > + source.size) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // get length; sanity check it + unsigned long length = chunk_length(chunk); + if (length > __INT_MAX__) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // make sure chunk header+paylaod is not larger than the total + // compressed + if (static_cast(chunk - source.buffer + length + 12) > + source.size) { + SET_ERROR(PNG_EMALFORMED); + return error; + } + + // parse chunks + if (chunk_type(chunk) == CHUNK_IDAT) { + compressed_size += length; + } else if (chunk_type(chunk) == CHUNK_IEND) { + break; + } else if (chunk_critical(chunk)) { + SET_ERROR(PNG_EUNSUPPORTED); + return error; + } + + chunk += chunk_length(chunk) + 12; + } + + // allocate enough space for the (compressed and filtered) image data + unsigned char *compressed = + compressed_size == 0 + ? nullptr + : static_cast(malloc(compressed_size)); + if (compressed == nullptr) { + SET_ERROR(PNG_ENOMEM); + return error; + } + + /* scan through the chunks again, this time copying the values into + * our compressed buffer. there's no reason to validate anything a second + * time. */ + chunk = source.buffer + 33; + while (chunk < source.buffer + source.size) { + unsigned long length = chunk_length(chunk); + const unsigned char *data = chunk + 8; // the data in the chunk + + // parse chunks + if (chunk_type(chunk) == CHUNK_IDAT) { + memcpy(compressed + compressed_index, data, length); + compressed_index += length; + } else if (chunk_type(chunk) == CHUNK_IEND) { + break; + } + + chunk += chunk_length(chunk) + 12; + } + + // allocate space to store inflated (but still filtered) data + unsigned long inflated_size = + ((width * (height * get_bpp() + 7)) / 8) + height; + unsigned char *inflated = + static_cast(malloc(inflated_size)); + if (inflated == nullptr) { + free(compressed); + SET_ERROR(PNG_ENOMEM); + return error; + } + + // decompress image data + enum error err = + uz_inflate(inflated, inflated_size, compressed, compressed_size); + if (err != PNG_EOK) { + free(compressed); + free(inflated); + return error; + } + + // free the compressed compressed data + free(compressed); + + // allocate final image buffer + size = (height * width * get_bpp() + 7) / 8; + buffer = static_cast(malloc(size)); + if (buffer == nullptr) { + free(inflated); + size = 0; + SET_ERROR(PNG_ENOMEM); + return error; + } + + // unfilter scanlines + post_process_scanlines(buffer, inflated, this); + free(inflated); + + if (error != PNG_EOK) { + free(buffer); + buffer = nullptr; + size = 0; + } else { + state = STATE_DECODED; + } + + // we are done with our input buffer; free it if we own it + free_source(); + + return error; +} + +PNG::PNG(const unsigned char *buffer, unsigned long size) + : width(0), + height(0), + color_type(COLOR_RGBA), + color_depth(8), + format(RGBA8), + buffer(nullptr), + size(0), + state(STATE_NEW), + error(PNG_EOK), + error_line(0) { + source.buffer = buffer; + source.size = size; + source.owning = 0; + + error = header(); +} + +PNG::~PNG() { + // deallocate image buffer + if (buffer != nullptr) { + free(buffer); + } + + // deallocate source buffer, if necessary + free_source(); +} diff --git a/kernel/utils/png.h b/kernel/utils/png.h new file mode 100644 index 0000000..d178014 --- /dev/null +++ b/kernel/utils/png.h @@ -0,0 +1,222 @@ +/*! \file + * \brief \ref PNG library + * + * The PNG library 'uPNG' was written by Sean Middleditch and Lode Vandevenne + * and modified for StuBS by Bernhard Heinloth. + * + * \see https://github.com/elanthis/upng + * + * uPNG -- derived from LodePNG version 20100808 + * + * Copyright (c) 2005-2010 Lode Vandevenne + * Copyright (c) 2010 Sean Middleditch + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not + *be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + */ + +#pragma once + +/**! \brief Portable Network Graphics file format + */ +class PNG { + public: + enum error { + PNG_EOK = 0, ///< success (no error) + PNG_ENOMEM = 1, ///< memory allocation failed + PNG_ENOTFOUND = 2, ///< resource not found (file missing) + PNG_ENOTPNG = 3, ///< image data does not have a PNG header + PNG_EMALFORMED = 4, ///< image data is not a valid PNG image + PNG_EUNSUPPORTED = 5, ///< critical PNG chunk type is not supported + PNG_EUNINTERLACED = 6, ///< image interlacing is not supported + PNG_EUNFORMAT = 7, ///< image color format is not supported + PNG_EPARAM = 8, ///< invalid parameter to method call + PNG_EIOERROR = 9 ///< Filesystem issues + }; + + enum format { + BADFORMAT, ///< Invalid format + RGB8, ///< 24bit RGB (8bit per color) + RGB16, ///< 48bit RGB (16bit per color) + RGBA8, ///< 32bit RGB (including alpha channel) + RGBA16, ///< 64bit RGB (including alpha channel) + LUMINANCE1, ///< Monochrome (black-white) + LUMINANCE2, ///< four shades of gray (2bit gray scale) + LUMINANCE4, ///< 16 shades of gray (4bit gray scale) + LUMINANCE8, ///< 8bit gray scale + LUMINANCE_ALPHA1, ///< Monochrome (black-white) with alpha channel + LUMINANCE_ALPHA2, ///< 2bit gray scale with alpha channel + LUMINANCE_ALPHA4, ///< 4bit gray scale with alpha channel + LUMINANCE_ALPHA8 ///< 8bit gray scale with alpha channel + }; + + private: + enum color { COLOR_LUM = 0, COLOR_RGB = 2, COLOR_LUMA = 4, COLOR_RGBA = 6 }; + + unsigned width = 0; + unsigned height = 0; + + enum color color_type; + unsigned color_depth; + enum format format = BADFORMAT; + + unsigned char* buffer = nullptr; + unsigned long size = 0; + + enum { + STATE_ERROR = -1, + STATE_DECODED = 0, + STATE_HEADER = 1, + STATE_NEW = 2 + } state; + + struct { + const unsigned char* buffer; + unsigned long size; + char owning; + } source; + + struct huffman_tree { + unsigned* tree2d; + unsigned maxbitlen; ///< maximum number of bits a single code can get + unsigned + numcodes; ///< number of symbols in the alphabet = number of codes + }; + + void free_source(); + static void huffman_tree_init(struct huffman_tree* tree, unsigned* buffer, + unsigned numcodes, unsigned maxbitlen); + void huffman_tree_create_lengths(struct huffman_tree* tree, + const unsigned* bitlen); + unsigned huffman_decode_symbol(const unsigned char* in, unsigned long* bp, + const struct huffman_tree* codetree, + unsigned long inlength); + void get_tree_inflate_dynamic(struct huffman_tree* codetree, + struct huffman_tree* codetreeD, + struct huffman_tree* codelengthcodetree, + const unsigned char* in, unsigned long* bp, + unsigned long inlength); + void inflate_huffman(unsigned char* out, unsigned long outsize, + const unsigned char* in, unsigned long* bp, + unsigned long* pos, unsigned long inlength, + unsigned btype); + void inflate_uncompressed(unsigned char* out, unsigned long outsize, + const unsigned char* in, unsigned long* bp, + unsigned long* pos, unsigned long inlength); + enum error uz_inflate_data(unsigned char* out, unsigned long outsize, + const unsigned char* in, unsigned long insize, + unsigned long inpos); + enum error uz_inflate(unsigned char* out, unsigned long outsize, + const unsigned char* in, unsigned long insize); + void unfilter_scanline(unsigned char* recon, const unsigned char* scanline, + const unsigned char* precon, unsigned long bytewidth, + unsigned char filterType, unsigned long length); + void unfilter(unsigned char* out, const unsigned char* in, unsigned w, + unsigned h, unsigned bpp); + static void remove_padding_bits(unsigned char* out, const unsigned char* in, + unsigned long olinebits, + unsigned long ilinebits, unsigned h); + void post_process_scanlines(unsigned char* out, unsigned char* in, + const PNG* info_png); + enum format determine_format(); + + protected: + enum error error; + unsigned error_line; + + /*! \brief Extract header (image attributes) + */ + enum error header(); + + /*! \brief Decode whole image + */ + enum error decode(); + + public: + /*! \brief Load PNG image from memory + * \param buffer pointer to memory buffer + * \param size size of memory buffer + */ + PNG(const unsigned char* buffer, unsigned long size); + + /*! \brief Free memory reserved for PNG image + */ + ~PNG(); + + /*! \brief Width of image (pixels) + */ + unsigned get_width() const { return width; } + + /*! \brief Height of image (pixels) + */ + unsigned get_height() const { return height; } + + /*! \brief Bits per pixel + */ + unsigned get_bpp() const { return get_bitdepth() * get_components(); } + + /*! \brief Depth of color (bits pro color channel) + */ + unsigned get_bitdepth() const { return color_depth; } + + /*! \brief Number of components per pixel + */ + unsigned get_components() const { + switch (color_type) { + case COLOR_LUM: + return 1; + case COLOR_RGB: + return 3; + case COLOR_LUMA: + return 2; + case COLOR_RGBA: + return 4; + default: + return 0; + } + } + + /*! \brief Number of bytes per pixel + */ + unsigned get_pixelsize() const { + unsigned bits = get_bitdepth() * get_components(); + bits += bits % 8; + return bits; + } + + /*! \brief Retrieve the format + */ + enum format get_format() const { return format; } + + /*! \brief Image buffer address + * \return Pointer to image buffer + */ + const unsigned char* get_buffer() { + decode(); + return buffer; + } + + /*! \brief Size of image buffer + * \return Total size of image buffer in bytes + */ + unsigned get_size() { + decode(); + return size; + } +}; diff --git a/kernel/utils/random.cc b/kernel/utils/random.cc new file mode 100644 index 0000000..caa7bc9 --- /dev/null +++ b/kernel/utils/random.cc @@ -0,0 +1,42 @@ + +#include "./random.h" + +Random::Random(uint32_t seed) { + mt[0] = seed; + + for (uint32_t i = 1; i < N; i++) { + mt[i] = (F * (mt[i - 1] ^ (mt[i - 1] >> 30)) + i); + } + + index = N; +} + +uint32_t Random::number() { + uint16_t v = index; + + if (index >= N) { + // Twist + for (uint32_t i = 0; i < N; i++) { + uint32_t x = (mt[i] & MASK_UPPER) + (mt[(i + 1) % N] & MASK_LOWER); + + uint32_t xA = x >> 1; + + if ((x & 0x1) != 0) { + xA ^= A; + } + + mt[i] = mt[(i + M) % N] ^ xA; + } + v = index = 0; + } + + uint32_t y = mt[v]; + index = v + 1; + + y ^= (y >> U); + y ^= (y << S) & B; + y ^= (y << T) & C; + y ^= (y >> L); + + return y; +} diff --git a/kernel/utils/random.h b/kernel/utils/random.h new file mode 100644 index 0000000..544c248 --- /dev/null +++ b/kernel/utils/random.h @@ -0,0 +1,51 @@ + +/*! \file + * \brief Class \ref Random (PRNG based on Mersenne Twister) + */ + +#pragma once + +#include "types.h" + +/*! Mersenne Twister (32 bit pseudorandom number generator) + * + * \see [Wikipedia](https://en.wikipedia.org/wiki/Mersenne_Twister) + */ +class Random { + private: + static const uint32_t N = 624; + static const uint32_t M = 397; + static const uint32_t R = 31; + static const uint32_t A = 0x9908B0DF; + + // initialization multiplier + static const uint32_t F = 1812433253; + + static const uint32_t U = 11; + + static const uint32_t S = 7; + static const uint32_t B = 0x9D2C5680; + + static const uint32_t T = 15; + static const uint32_t C = 0xEFC60000; + + static const uint32_t L = 18; + + static const uint32_t MASK_LOWER = (1UL << R) - 1; + static const uint32_t MASK_UPPER = (1UL << R); + + uint32_t mt[N]; + uint16_t index; + + public: + /*! \brief Constructor + * + * \param seed initial value (seed) for the pseudorandom number generator. + */ + explicit Random(uint32_t seed); + + /*! \brief Get the next (pseudo)random number. + * \return some number + */ + uint32_t number(); +}; diff --git a/kernel/utils/size.h b/kernel/utils/size.h new file mode 100644 index 0000000..2fd2d2e --- /dev/null +++ b/kernel/utils/size.h @@ -0,0 +1,17 @@ +/*! \file + * \brief Template function to determine the length of an array + */ + +#pragma once + +#include "../types.h" + +/* \brief Helper to retrieve the number of elements in an array + * (Warning: template magic) + * \param Array + * \return Number of elements + */ +template +constexpr size_t size(T (& /*unused*/)[N]) { + return N; +} diff --git a/kernel/utils/sort.h b/kernel/utils/sort.h new file mode 100644 index 0000000..dc6b7f5 --- /dev/null +++ b/kernel/utils/sort.h @@ -0,0 +1,30 @@ +#pragma once + +template +void arraysort(T *array, int size, int (*comp)(T *a, T *b)) { + // this is shellsort + static const int gaps[] = {3548, 1577, 701, 301, 132, 57, 23, 10, 4, 1}; + static const int gapsize = 10; + + for (int g = 0; g < gapsize; ++g) { + const int gap = gaps[g]; + for (int i = gap; i < size; i += 1) { + T tmp = array[i]; + int j; + for (j = i; (j >= gap) && (comp(array + j - gap, &tmp) > 0); + j -= gap) + array[j] = array[j - gap]; + array[j] = tmp; + } + } +} + +template +bool arraysort_check(T *array, int size, int (*comp)(T *a, T *b)) { + for (int i = 0; i < size - 1; ++i) { + if (comp(array + i, array + i + 1) > 0) { + return false; + } + } + return true; +} diff --git a/kernel/utils/string.cc b/kernel/utils/string.cc new file mode 100644 index 0000000..ae3f1b7 --- /dev/null +++ b/kernel/utils/string.cc @@ -0,0 +1,117 @@ +#include "string.h" + +extern "C" char *strchrnul(const char *s, int c) { + if (s != nullptr) { + while (*s != '\0') { + if (*s == c) { + break; + } + s++; + } + } + return const_cast(s); +} + +extern "C" char *strchr(const char *s, int c) { + if (s != nullptr) { + s = strchrnul(s, c); + if (*s == c) { + return const_cast(s); + } + } + return nullptr; +} + +extern "C" int strcmp(const char *s1, const char *s2) { + if (s1 == nullptr || s2 == nullptr) { + return 0; + } + + while (*s1 == *s2++) { + if (*s1++ == '\0') { + return 0; + } + } + return static_cast(*s1) - static_cast(*(s2 - 1)); +} + +extern "C" int strncmp(const char *s1, const char *s2, size_t n) { + if (s1 != nullptr && s2 != nullptr) { + for (size_t i = 0; i < n; i++) { + if (s1[i] != s2[i]) { + return static_cast(s1[i]) - static_cast(s2[i]); + } else if (s1[i] == '\0') { + break; + } + } + } + return 0; +} + +extern "C" size_t strlen(const char *s) { + size_t len = 0; + if (s != nullptr) { + while (*s++ != '\0') { + len++; + } + } + + return len; +} + +extern "C" char *strcpy(char *dest, const char *src) { // NOLINT + char *r = dest; + if (dest != nullptr && src != nullptr) { + while ((*dest++ = *src++) != '\0') { + } + } + return r; +} + +extern "C" char *strncpy(char *dest, const char *src, size_t n) { + char *r = dest; + if (dest != nullptr && src != nullptr) { + while ((n--) != 0 && (*dest++ = *src++) != '\0') { + } + } + return r; +} + +extern "C" void *memcpy(void *__restrict__ dest, void const *__restrict__ src, + size_t size) { + uint8_t *destination = reinterpret_cast(dest); + uint8_t const *source = (uint8_t const *)src; + + for (size_t i = 0; i != size; ++i) { + destination[i] = source[i]; + } + + return dest; +} + +extern "C" void *memmove(void *dest, void const *src, size_t size) { + uint8_t *destination = reinterpret_cast(dest); + uint8_t const *source = reinterpret_cast(src); + + if (source > destination) { + for (size_t i = 0; i != size; ++i) { + destination[i] = source[i]; + } + } else { + for (size_t i = size; i != 0; --i) { + destination[i - 1] = source[i - 1]; + } + } + + return dest; +} + +extern "C" void *memset(void *dest, int pattern, size_t size) { + uint8_t *destination = reinterpret_cast(dest); + + for (size_t i = 0; i != size; ++i) { + destination[i] = static_cast(pattern); + } + + return dest; +} diff --git a/kernel/utils/string.h b/kernel/utils/string.h new file mode 100644 index 0000000..fb9e1cc --- /dev/null +++ b/kernel/utils/string.h @@ -0,0 +1,108 @@ +/*! \file + * \brief General purpose \ref string "String functions" + */ +#pragma once + +#include "types.h" + +/*! \defgroup string String function + * \brief String functions as provided by `%string.h` in the C standard library + */ + +/*! \brief Find the first occurrence of a character in a string + * \ingroup string + * \param s string to + * \param c character to find + * \return Pointer to first occurrence of the character + * or to null byte at the end of the string if not found + */ +extern "C" char *strchrnul(const char *s, int c); + +/*! \brief Find the first occurrence of a character in a string + * \ingroup string + * \param s string to + * \param c character to find + * \return Pointer to first occurrence of the character + * or to nullptr if not found + */ +extern "C" char *strchr(const char *s, int c); + +/*! \brief Compare two strings + * \ingroup string + * \param s1 first string + * \param s2 second string + * \return an integer less than, equal to, or greater than zero if first string + * is found, respectively, to be less than, to match, or be greater than second + * string + */ +extern "C" int strcmp(const char *s1, const char *s2); + +/*! \brief Compare two strings + * \ingroup string + * \param s1 first string + * \param s2 second string + * \param n number of bytes to compare + * \return an integer less than, equal to, or greater than zero if the given + * number of bytes of the first string are found, respectively, to be less than, + * to match, or be greater than second string + */ +extern "C" int strncmp(const char *s1, const char *s2, size_t n); + +/*! \brief Calculate the length of a string + * \ingroup string + * \param s pointer to a string + * \return number of bytes in the string + */ +extern "C" size_t strlen(const char *s); + +/*! \brief Copy the contents of a string + * including the terminating null byte (`\0`) + * \ingroup string + * \param dest destination string buffer + * \param src source string buffer + * \return a pointer to the destination string buffer + * \note Beware of buffer overruns! + */ +extern "C" char *strcpy(char *dest, const char *src); // NOLINT + +/*! \brief Copy the contents of a string up to a maximum length + * or the terminating null byte (`\0`), whatever comes first. + * \ingroup string + * \param dest destination string buffer + * \param src source string buffer + * \param n maximum number of bytes to copy + * \return a pointer to the destination string buffer + * \note If there is no null byte (`\0`) among the first `n` bytes, the + * destination will not be null-terminated! + */ +extern "C" char *strncpy(char *dest, const char *src, size_t n); + +/*! \brief Copy a memory area + * \ingroup string + * \param dest destination buffer + * \param src source buffer + * \param size number of bytes to copy + * \return pointer to destination + * \note The memory must not overlap! + */ +extern "C" void *memcpy(void *__restrict__ dest, void const *__restrict__ src, + size_t size); + +/*! \brief Copy a memory area + * while the source may overlap with the destination + * \ingroup string + * \param dest destination buffer + * \param src source buffer + * \param size number of bytes to copy + * \return pointer to destination + */ +extern "C" void *memmove(void *dest, void const *src, size_t size); + +/*! \brief Fill a memory area with a pattern + * \ingroup string + * \param dest destination buffer + * \param pattern single byte pattern + * \param size number of bytes to fill with pattern + * \return pointer to destination + */ +extern "C" void *memset(void *dest, int pattern, size_t size); diff --git a/libsys/Makefile b/libsys/Makefile new file mode 100644 index 0000000..e24d7fb --- /dev/null +++ b/libsys/Makefile @@ -0,0 +1,23 @@ +# -------------------------------------------------------------------------- +# Files to be compiled (important: defined prior to importing common.mk!) +CC_SOURCES = $(shell find * -name "*.cc") +ASM_SOURCES = $(shell find * -name "*.asm") + +# ----------------------------------------------------------------------------- +# Include global variables and default targets + +include ../tools/common.mk + +# -------------------------------------------------------------------------- +# Default target + +.DEFAULT_GOAL = all +all: $(BUILDDIR)/libsys.a + +# -------------------------------------------------------------------------- +# Package libsys.a + +$(BUILDDIR)/libsys.a: $(ASM_OBJECTS) $(CC_OBJECTS) $(MAKEFILE_LIST) + @echo "AR $@" + @mkdir -p $(@D) + $(VERBOSE) $(AR) rcs $@ $(ASM_OBJECTS) $(CC_OBJECTS) diff --git a/libsys/iostream.h b/libsys/iostream.h new file mode 100644 index 0000000..94cae8e --- /dev/null +++ b/libsys/iostream.h @@ -0,0 +1,24 @@ +#pragma once + +#include "outputstream.h" +#include "stub.h" + +class IOStream : public OutputStream { + private: + IOStream(IOStream ©); // no copy + int fd; + + public: + explicit IOStream(int sysfd = 0) : fd(sysfd) {} + + ~IOStream() { + if (pos > 0) { + sys_write(fd, buffer, pos); + } + } + + void flush() override { + sys_write(fd, buffer, pos); + pos = 0; + } +}; diff --git a/libsys/libc.cc b/libsys/libc.cc new file mode 120000 index 0000000..dae7455 --- /dev/null +++ b/libsys/libc.cc @@ -0,0 +1 @@ +../kernel/compiler/libc.cc \ No newline at end of file diff --git a/libsys/libc.h b/libsys/libc.h new file mode 120000 index 0000000..7c40201 --- /dev/null +++ b/libsys/libc.h @@ -0,0 +1 @@ +../kernel/compiler/libc.h \ No newline at end of file diff --git a/libsys/math.h b/libsys/math.h new file mode 120000 index 0000000..85a3011 --- /dev/null +++ b/libsys/math.h @@ -0,0 +1 @@ +../kernel/utils/math.h \ No newline at end of file diff --git a/libsys/outputstream.cc b/libsys/outputstream.cc new file mode 120000 index 0000000..9d60da6 --- /dev/null +++ b/libsys/outputstream.cc @@ -0,0 +1 @@ +../kernel/object/outputstream.cc \ No newline at end of file diff --git a/libsys/outputstream.h b/libsys/outputstream.h new file mode 120000 index 0000000..91734d0 --- /dev/null +++ b/libsys/outputstream.h @@ -0,0 +1 @@ +../kernel/object/outputstream.h \ No newline at end of file diff --git a/libsys/rand.cc b/libsys/rand.cc new file mode 100644 index 0000000..ea55744 --- /dev/null +++ b/libsys/rand.cc @@ -0,0 +1,68 @@ +#include "rand.h" + +// Mersenne Twister (32 bit pseudorandom number generator) +// https://en.wikipedia.org/wiki/Mersenne_Twister + +static const uint32_t N = 624; +static const uint32_t M = 397; +static const uint32_t R = 31; +static const uint32_t A = 0x9908B0DF; + +// initialization multiplier +static const uint32_t F = 1812433253; + +static const uint32_t U = 11; + +static const uint32_t S = 7; +static const uint32_t B = 0x9D2C5680; + +static const uint32_t T = 15; +static const uint32_t C = 0xEFC60000; + +static const uint32_t L = 18; + +static const uint32_t MASK_LOWER = (1ULL << R) - 1; +static const uint32_t MASK_UPPER = (1ULL << R); + +static uint32_t mt[N]; +static uint16_t index; + +void srand(const uint32_t seed) { + mt[0] = seed; + + for (uint32_t i = 1; i < N; i++) { + mt[i] = (F * (mt[i - 1] ^ (mt[i - 1] >> 30)) + i); + } + + index = N; +} + +uint32_t rand() { + uint16_t v = index; + + if (index >= N) { + // Twist + for (uint32_t i = 0; i < N; i++) { + uint32_t x = (mt[i] & MASK_UPPER) + (mt[(i + 1) % N] & MASK_LOWER); + + uint32_t xA = x >> 1; + + if ((x & 0x1) != 0) { + xA ^= A; + } + + mt[i] = mt[(i + M) % N] ^ xA; + } + v = index = 0; + } + + uint32_t y = mt[v]; + index = v + 1; + + y ^= (y >> U); + y ^= (y << S) & B; + y ^= (y << T) & C; + y ^= (y >> L); + + return y; +} diff --git a/libsys/rand.h b/libsys/rand.h new file mode 100644 index 0000000..2067d11 --- /dev/null +++ b/libsys/rand.h @@ -0,0 +1,9 @@ +#pragma once + +#include "types.h" + +const uint32_t RAND_MAX = UINT32_MAX; + +void srand(uint32_t seed); + +uint32_t rand(); diff --git a/libsys/string.cc b/libsys/string.cc new file mode 120000 index 0000000..cc1c830 --- /dev/null +++ b/libsys/string.cc @@ -0,0 +1 @@ +../kernel/utils/string.cc \ No newline at end of file diff --git a/libsys/string.h b/libsys/string.h new file mode 120000 index 0000000..7874f99 --- /dev/null +++ b/libsys/string.h @@ -0,0 +1 @@ +../kernel/utils/string.h \ No newline at end of file diff --git a/libsys/stringbuffer.cc b/libsys/stringbuffer.cc new file mode 120000 index 0000000..696ab38 --- /dev/null +++ b/libsys/stringbuffer.cc @@ -0,0 +1 @@ +../kernel/object/stringbuffer.cc \ No newline at end of file diff --git a/libsys/stringbuffer.h b/libsys/stringbuffer.h new file mode 120000 index 0000000..8db9241 --- /dev/null +++ b/libsys/stringbuffer.h @@ -0,0 +1 @@ +../kernel/object/stringbuffer.h \ No newline at end of file diff --git a/libsys/stub.asm b/libsys/stub.asm new file mode 120000 index 0000000..05408e7 --- /dev/null +++ b/libsys/stub.asm @@ -0,0 +1 @@ +../kernel/syscall/stub.asm \ No newline at end of file diff --git a/libsys/stub.h b/libsys/stub.h new file mode 120000 index 0000000..9419caf --- /dev/null +++ b/libsys/stub.h @@ -0,0 +1 @@ +../kernel/syscall/stub.h \ No newline at end of file diff --git a/libsys/types.h b/libsys/types.h new file mode 120000 index 0000000..a962473 --- /dev/null +++ b/libsys/types.h @@ -0,0 +1 @@ +../kernel/types.h \ No newline at end of file diff --git a/nix-develop.sh b/nix-develop.sh new file mode 100644 index 0000000..5c398c7 --- /dev/null +++ b/nix-develop.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env sh +## This repo should not directly contain a flake.nix, to avoid it being automatically copied to the (locally) world-readable Nix store. +exec nix develop path:"$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )"/utils "$@" diff --git a/tools/build.mk b/tools/build.mk new file mode 100644 index 0000000..7e7e9f7 --- /dev/null +++ b/tools/build.mk @@ -0,0 +1,153 @@ +# Build the kernel + +# Top Level Folder all generated files will be placed in. +ROOTBUILDDIR = build +# Folder the generated files will be placed in. +BUILDDIR ?= $(ROOTBUILDDIR) +# Build folder suffixes +OPTTAG = opt +NOOPTTAG = noopt +DBGTAG = dbg +VERBOSETAG = verbose + +# C++ +CXX ?= $(PREFIX)clang++ +# on macos the default compiler is called c++, switch to clang++ +ifeq ($(shell uname),Darwin) + ifeq ($(CXX),c++) + CXX := clang++ + endif +endif + +CXXFLAGS_ARCH = -m64 +CXXFLAGS_DEFAULT = -std=c++23 -ffreestanding -fno-pic -nodefaultlibs -nostdlib -nostdinc -I. -fno-rtti -fno-exceptions -Wno-write-strings -fno-stack-protector -mno-red-zone -g -gdwarf-2 -fno-use-cxa-atexit -no-pie -nostartfiles +# Enable 16-byte compare-and-exchange instruction for debugging purposes (stack alignment) +CXXFLAGS_DEFAULT += -mcx16 +CXXFLAGS_OPT = -O3 -fomit-frame-pointer +CXXFLAGS_WARNING = -Wall -Wextra -Werror -Wno-error=unused-parameter -Wno-error=unused-variable -Wno-non-virtual-dtor +CXXFLAGS_CLANG = -Wno-error=unused-private-field -Wno-implicit-exception-spec-mismatch -Wno-error=unused-const-variable -Wno-unused-command-line-argument -Wno-unused-const-variable -fno-strict-aliasing +ifeq ($(shell uname),Darwin) + CXXFLAGS_CLANG += -target x86_64-pc-linux-gnu -fuse-ld=lld +endif +CXXFLAGS_GCC = -fno-tree-loop-distribute-patterns -Wstack-usage=4096 -Wno-error=stack-usage= +CXXFLAGS_NOFPU = -mno-mmx -mno-sse -mgeneral-regs-only +CXXFLAGS = $(CXXFLAGS_ARCH) $(CXXFLAGS_DEFAULT) $(CXXFLAGS_OPT) $(CXXFLAGS_NOFPU) $(CXXFLAGS_WARNING) +# Compiler specific flags +ifneq (,$(findstring clang,$(CXX))) + COMPILER := CLANG + CXXFLAGS += $(CXXFLAGS_CLANG) +else ifneq (,$(findstring g++,$(CXX))) + COMPILER := GCC + # Configures -Warray-bounds warning to allow accessing in the NULL page + # Necessary to read the Extended BIOS Data Area at 0x40e + ifeq "$(shell expr `$(CXX) -dumpversion | cut -f1 -d.` \>= 12)" "1" + CXXFLAGS += --param=min-pagesize=0x40e + endif + CXXFLAGS += $(CXXFLAGS_GCC) +else + COMPILER := +endif + +# Assembly +ASM = nasm +ASMFLAGS = -f elf64 + +# Additional build utilities +# If llvm tools are available, use them +ifneq (,$(shell which llvm-objcopy 2>/dev/null)) + PREFIX = llvm- +endif +OBJCOPY = $(PREFIX)objcopy +STRIP = $(PREFIX)strip +AR = $(PREFIX)ar + +# Subdirectories with sources +VPATH = $(sort $(dir $(CC_SOURCES) $(ASM_SOURCES))) + +# Lists of object files that are generated by compilation: +# Note that the variables containing the input files are to be defined by +# the Makefiles prior to including this common.mk. +CC_OBJECTS = $(addprefix $(BUILDDIR)/,$(CC_SOURCES:.cc=.o)) +DEP_FILES = $(addprefix $(BUILDDIR)/,$(CC_SOURCES:.cc=.d) $(addsuffix .d,$(ASM_SOURCES))) +ASM_OBJECTS = $(addprefix $(BUILDDIR)/,$(addsuffix .o,$(ASM_SOURCES))) + +# Dependency files +$(BUILDDIR)/%.d : %.cc $(MAKEFILE_LIST) + @echo "DEP $<" + @mkdir -p $(@D) + $(VERBOSE) $(CXX) $(CXXFLAGS) -MM -MT $(BUILDDIR)/$*.o -MF $@ $< + + +$(BUILDDIR)/%.asm.d : %.asm $(MAKEFILE_LIST) + @echo "DEP $<" + @mkdir -p $(@D) + $(VERBOSE) $(ASM) $(ASMFLAGS) -M -MT $(BUILDDIR)/$*.asm.o -MF $@ $< + + +# Object files +$(BUILDDIR)/%.o : %.cc $(MAKEFILE_LIST) + @echo "CXX $<" + @mkdir -p $(@D) + $(VERBOSE) $(CXX) -c $(CXXFLAGS) -o $@ $< + +$(BUILDDIR)/%.asm.o : %.asm $(MAKEFILE_LIST) + @echo "ASM $<" + @mkdir -p $(@D) + $(VERBOSE) $(ASM) $(ASMFLAGS) -o $@ $< + + +# The standard target 'clean' removes the whole generated system, the object files, and the dependency files. +clean:: + rm -rf "$(BUILDDIR)" + + +# Target issuing a nested call to make generating a fully optimized systems without assertions. +%-$(OPTTAG): + $(VERBOSE) $(MAKE) BUILDDIR="$(BUILDDIR)/$(OPTTAG)" ISODIR="$(ISODIR)/$(OPTTAG)" CXXFLAGS_OPT="-Ofast -fomit-frame-pointer -flto -march=westmere -DNDEBUG" $* + + +# Target issuing a nested call to make generating a non-optimized system. +%-$(NOOPTTAG): + $(VERBOSE) $(MAKE) BUILDDIR="$(BUILDDIR)/$(NOOPTTAG)" ISODIR="$(ISODIR)/$(NOOPTTAG)" CXXFLAGS_OPT="-O0" $* + + +# Target issuing a nested call to make generating a system optimized for debugging. +%-$(DBGTAG): + $(VERBOSE) $(MAKE) BUILDDIR="$(BUILDDIR)/$(DBGTAG)" ISODIR="$(ISODIR)/$(DBGTAG)" CXXFLAGS_OPT="-Og -fno-omit-frame-pointer" $* + + +# Target issuing a nested call to make generating a system with verbose output. +%-$(VERBOSETAG): + $(VERBOSE) $(MAKE) BUILDDIR="$(BUILDDIR)/$(VERBOSETAG)" ISODIR="$(ISODIR)/$(VERBOSETAG)" CXXFLAGS_OPT="-DVERBOSE" $* + + +# Documentation +help:: + @$(echo) "" \ + "All targets exist in different flavours in addition to \e[2;3m\e[0m:\n" \ + "\e[2;3m\e[0;3m-noopt\e[0m, \e[2;3m\e[0;3m-opt\e[0m, \e[2;3m\e[0;3m-dbg\e[0m, and \e[2;3m\e[0;3m-verbose\e[0m.\n" \ + "Targets suffixed with \e[3m-noopt\e[0m are compiled without optimizations,\n" \ + "\e[3m-opt\e[0m targets produce a highly optimized binary, while\n" \ + "\e[3m-dbg\e[0m targets only use optimizations not hindering debugging.\n" \ + "Targets suffixed with \e[3m-verbose\e[0m generate binaries including\n" \ + "verbose output (via \e[3mDBG_VERBOSE\e[0m), making such targets useful for debugging.\n" \ + "To get a verbose make output, clear VERBOSE, e.g. \e[3mmake VERBOSE=\e[0m.\n" \ + "The following targets are available (each target can be suffixed by \e[3m-noopt\e[0m\n" \ + "and \e[3m-verbose\e[0m):\n\n" \ + " \e[3mall\e[0m Builds $(PROJECT), generating an ELF binary\n\n" + + +# Print warnings, if appropriate +ifeq (,$(COMPILER)) +$(warning Unknown (and potentially unsupported) compiler "$(CXX)"!) +endif + + +# Include dependency files (generated via gcc flag -MM) +ifneq ($(MAKECMDGOALS),clean) +-include $(DEP_FILES) +endif + + +# Phony targets +.PHONY: clean help diff --git a/tools/common.mk b/tools/common.mk new file mode 100644 index 0000000..c9e8a8c --- /dev/null +++ b/tools/common.mk @@ -0,0 +1,35 @@ +# Common include Makefile + +# Hide commands +VERBOSE = @ +# Prefix for toolchain binaries +PREFIX ?= +# Project name +PROJECT ?= "StuBSmI" + +help:: + @$(echo) "\n" \ + "\e[1mMAKEFILE for the teaching operating system $(PROJECT)\e[0m\n" \ + "--------------------------------------------------\n\n" \ + "Executing '\e[4mmake\e[0m' will compile the operating system from source.\n" + + +# Get current directory path +CURRENT_DIR := $(dir $(lastword $(MAKEFILE_LIST))) + +# Include Makefile scripts +include $(CURRENT_DIR)/build.mk +include $(CURRENT_DIR)/qemu.mk +include $(CURRENT_DIR)/image.mk +include $(CURRENT_DIR)/linter.mk +include $(CURRENT_DIR)/remote.mk + + +# Disable buitlin rules +MAKEFLAGS += --no-builtin-rules + +# Disable buitlin rules +MAKEFLAGS += --no-print-directory + +# Disable buitlin suffixes +.SUFFIXES: diff --git a/tools/cpplint.py b/tools/cpplint.py new file mode 100644 index 0000000..13fb35d --- /dev/null +++ b/tools/cpplint.py @@ -0,0 +1,6890 @@ +#!/usr/bin/env python +# +# Copyright (c) 2009 Google Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +"""Does google-lint on c++ files. + +The goal of this script is to identify places in the code that *may* +be in non-compliance with google style. It does not attempt to fix +up these problems -- the point is to educate. It does also not +attempt to find all problems, or to ensure that everything it does +find is legitimately a problem. + +In particular, we can get very confused by /* and // inside strings! +We do a small hack, which is to ignore //'s with "'s after them on the +same line, but it is far from perfect (in either direction). +""" + +import codecs +import copy +import getopt +import glob +import itertools +import math # for log +import os +import re +import sre_compile +import string +import sys +import sysconfig +import unicodedata +import xml.etree.ElementTree + +# if empty, use defaults +_valid_extensions = set([]) + +__VERSION__ = '1.5.2' + +try: + xrange # Python 2 +except NameError: + # -- pylint: disable=redefined-builtin + xrange = range # Python 3 + + +_USAGE = """ +Syntax: cpplint.py [--verbose=#] [--output=emacs|eclipse|vs7|junit|sed|gsed] + [--filter=-x,+y,...] + [--counting=total|toplevel|detailed] [--root=subdir] + [--repository=path] + [--linelength=digits] [--headers=x,y,...] + [--recursive] + [--exclude=path] + [--extensions=hpp,cpp,...] + [--includeorder=default|standardcfirst] + [--quiet] + [--version] + [file] ... + + Style checker for C/C++ source files. + This is a fork of the Google style checker with minor extensions. + + The style guidelines this tries to follow are those in + https://google.github.io/styleguide/cppguide.html + + Every problem is given a confidence score from 1-5, with 5 meaning we are + certain of the problem, and 1 meaning it could be a legitimate construct. + This will miss some errors, and is not a substitute for a code review. + + To suppress false-positive errors of a certain category, add a + 'NOLINT(category)' comment to the line. NOLINT or NOLINT(*) + suppresses errors of all categories on that line. + + The files passed in will be linted; at least one file must be provided. + Default linted extensions are %s. + Other file types will be ignored. + Change the extensions with the --extensions flag. + + Flags: + + output=emacs|eclipse|vs7|junit|sed|gsed + By default, the output is formatted to ease emacs parsing. Visual Studio + compatible output (vs7) may also be used. Further support exists for + eclipse (eclipse), and JUnit (junit). XML parsers such as those used + in Jenkins and Bamboo may also be used. + The sed format outputs sed commands that should fix some of the errors. + Note that this requires gnu sed. If that is installed as gsed on your + system (common e.g. on macOS with homebrew) you can use the gsed output + format. Sed commands are written to stdout, not stderr, so you should be + able to pipe output straight to a shell to run the fixes. + + verbose=# + Specify a number 0-5 to restrict errors to certain verbosity levels. + Errors with lower verbosity levels have lower confidence and are more + likely to be false positives. + + quiet + Don't print anything if no errors are found. + + filter=-x,+y,... + Specify a comma-separated list of category-filters to apply: only + error messages whose category names pass the filters will be printed. + (Category names are printed with the message and look like + "[whitespace/indent]".) Filters are evaluated left to right. + "-FOO" and "FOO" means "do not print categories that start with FOO". + "+FOO" means "do print categories that start with FOO". + + Examples: --filter=-whitespace,+whitespace/braces + --filter=whitespace,runtime/printf,+runtime/printf_format + --filter=-,+build/include_what_you_use + + To see a list of all the categories used in cpplint, pass no arg: + --filter= + + counting=total|toplevel|detailed + The total number of errors found is always printed. If + 'toplevel' is provided, then the count of errors in each of + the top-level categories like 'build' and 'whitespace' will + also be printed. If 'detailed' is provided, then a count + is provided for each category like 'build/class'. + + repository=path + The top level directory of the repository, used to derive the header + guard CPP variable. By default, this is determined by searching for a + path that contains .git, .hg, or .svn. When this flag is specified, the + given path is used instead. This option allows the header guard CPP + variable to remain consistent even if members of a team have different + repository root directories (such as when checking out a subdirectory + with SVN). In addition, users of non-mainstream version control systems + can use this flag to ensure readable header guard CPP variables. + + Examples: + Assuming that Alice checks out ProjectName and Bob checks out + ProjectName/trunk and trunk contains src/chrome/ui/browser.h, then + with no --repository flag, the header guard CPP variable will be: + + Alice => TRUNK_SRC_CHROME_BROWSER_UI_BROWSER_H_ + Bob => SRC_CHROME_BROWSER_UI_BROWSER_H_ + + If Alice uses the --repository=trunk flag and Bob omits the flag or + uses --repository=. then the header guard CPP variable will be: + + Alice => SRC_CHROME_BROWSER_UI_BROWSER_H_ + Bob => SRC_CHROME_BROWSER_UI_BROWSER_H_ + + root=subdir + The root directory used for deriving header guard CPP variable. + This directory is relative to the top level directory of the repository + which by default is determined by searching for a directory that contains + .git, .hg, or .svn but can also be controlled with the --repository flag. + If the specified directory does not exist, this flag is ignored. + + Examples: + Assuming that src is the top level directory of the repository (and + cwd=top/src), the header guard CPP variables for + src/chrome/browser/ui/browser.h are: + + No flag => CHROME_BROWSER_UI_BROWSER_H_ + --root=chrome => BROWSER_UI_BROWSER_H_ + --root=chrome/browser => UI_BROWSER_H_ + --root=.. => SRC_CHROME_BROWSER_UI_BROWSER_H_ + + linelength=digits + This is the allowed line length for the project. The default value is + 80 characters. + + Examples: + --linelength=120 + + recursive + Search for files to lint recursively. Each directory given in the list + of files to be linted is replaced by all files that descend from that + directory. Files with extensions not in the valid extensions list are + excluded. + + exclude=path + Exclude the given path from the list of files to be linted. Relative + paths are evaluated relative to the current directory and shell globbing + is performed. This flag can be provided multiple times to exclude + multiple files. + + Examples: + --exclude=one.cc + --exclude=src/*.cc + --exclude=src/*.cc --exclude=test/*.cc + + extensions=extension,extension,... + The allowed file extensions that cpplint will check + + Examples: + --extensions=%s + + includeorder=default|standardcfirst + For the build/include_order rule, the default is to blindly assume angle + bracket includes with file extension are c-system-headers (default), + even knowing this will have false classifications. + The default is established at google. + standardcfirst means to instead use an allow-list of known c headers and + treat all others as separate group of "other system headers". The C headers + included are those of the C-standard lib and closely related ones. + + headers=x,y,... + The header extensions that cpplint will treat as .h in checks. Values are + automatically added to --extensions list. + (by default, only files with extensions %s will be assumed to be headers) + + Examples: + --headers=%s + --headers=hpp,hxx + --headers=hpp + + cpplint.py supports per-directory configurations specified in CPPLINT.cfg + files. CPPLINT.cfg file can contain a number of key=value pairs. + Currently the following options are supported: + + set noparent + filter=+filter1,-filter2,... + exclude_files=regex + linelength=80 + root=subdir + headers=x,y,... + + "set noparent" option prevents cpplint from traversing directory tree + upwards looking for more .cfg files in parent directories. This option + is usually placed in the top-level project directory. + + The "filter" option is similar in function to --filter flag. It specifies + message filters in addition to the |_DEFAULT_FILTERS| and those specified + through --filter command-line flag. + + "exclude_files" allows to specify a regular expression to be matched against + a file name. If the expression matches, the file is skipped and not run + through the linter. + + "linelength" allows to specify the allowed line length for the project. + + The "root" option is similar in function to the --root flag (see example + above). Paths are relative to the directory of the CPPLINT.cfg. + + The "headers" option is similar in function to the --headers flag + (see example above). + + CPPLINT.cfg has an effect on files in the same directory and all + sub-directories, unless overridden by a nested configuration file. + + Example file: + filter=-build/include_order,+build/include_alpha + exclude_files=.*\\.cc + + The above example disables build/include_order warning and enables + build/include_alpha as well as excludes all .cc from being + processed by linter, in the current directory (where the .cfg + file is located) and all sub-directories. +""" + +# We categorize each error message we print. Here are the categories. +# We want an explicit list so we can list them all in cpplint --filter=. +# If you add a new error message with a new category, add it to the list +# here! cpplint_unittest.py should tell you if you forget to do this. +_ERROR_CATEGORIES = [ + 'build/class', + 'build/c++11', + 'build/c++14', + 'build/c++tr1', + 'build/deprecated', + 'build/endif_comment', + 'build/explicit_make_pair', + 'build/forward_decl', + 'build/header_guard', + 'build/include', + 'build/include_subdir', + 'build/include_alpha', + 'build/include_order', + 'build/include_what_you_use', + 'build/namespaces_headers', + 'build/namespaces_literals', + 'build/namespaces', + 'build/printf_format', + 'build/storage_class', + 'legal/copyright', + 'readability/alt_tokens', + 'readability/braces', + 'readability/casting', + 'readability/check', + 'readability/constructors', + 'readability/fn_size', + 'readability/inheritance', + 'readability/multiline_comment', + 'readability/multiline_string', + 'readability/namespace', + 'readability/nolint', + 'readability/nul', + 'readability/strings', + 'readability/todo', + 'readability/utf8', + 'runtime/arrays', + 'runtime/casting', + 'runtime/explicit', + 'runtime/int', + 'runtime/init', + 'runtime/invalid_increment', + 'runtime/member_string_references', + 'runtime/memset', + 'runtime/indentation_namespace', + 'runtime/operator', + 'runtime/printf', + 'runtime/printf_format', + 'runtime/references', + 'runtime/string', + 'runtime/threadsafe_fn', + 'runtime/vlog', + 'whitespace/blank_line', + 'whitespace/braces', + 'whitespace/comma', + 'whitespace/comments', + 'whitespace/empty_conditional_body', + 'whitespace/empty_if_body', + 'whitespace/empty_loop_body', + 'whitespace/end_of_line', + 'whitespace/ending_newline', + 'whitespace/forcolon', + 'whitespace/indent', + 'whitespace/line_length', + 'whitespace/newline', + 'whitespace/operators', + 'whitespace/parens', + 'whitespace/semicolon', + 'whitespace/tab', + 'whitespace/todo', + ] + +# These error categories are no longer enforced by cpplint, but for backwards- +# compatibility they may still appear in NOLINT comments. +_LEGACY_ERROR_CATEGORIES = [ + 'readability/streams', + 'readability/function', + ] + +# The default state of the category filter. This is overridden by the --filter= +# flag. By default all errors are on, so only add here categories that should be +# off by default (i.e., categories that must be enabled by the --filter= flags). +# All entries here should start with a '-' or '+', as in the --filter= flag. +_DEFAULT_FILTERS = ['-build/include_alpha'] + +# The default list of categories suppressed for C (not C++) files. +_DEFAULT_C_SUPPRESSED_CATEGORIES = [ + 'readability/casting', + ] + +# The default list of categories suppressed for Linux Kernel files. +_DEFAULT_KERNEL_SUPPRESSED_CATEGORIES = [ + 'whitespace/tab', + ] + +# We used to check for high-bit characters, but after much discussion we +# decided those were OK, as long as they were in UTF-8 and didn't represent +# hard-coded international strings, which belong in a separate i18n file. + +# C++ headers +_CPP_HEADERS = frozenset([ + # Legacy + 'algobase.h', + 'algo.h', + 'alloc.h', + 'builtinbuf.h', + 'bvector.h', + 'complex.h', + 'defalloc.h', + 'deque.h', + 'editbuf.h', + 'fstream.h', + 'function.h', + 'hash_map', + 'hash_map.h', + 'hash_set', + 'hash_set.h', + 'hashtable.h', + 'heap.h', + 'indstream.h', + 'iomanip.h', + 'iostream.h', + 'istream.h', + 'iterator.h', + 'list.h', + 'map.h', + 'multimap.h', + 'multiset.h', + 'ostream.h', + 'pair.h', + 'parsestream.h', + 'pfstream.h', + 'procbuf.h', + 'pthread_alloc', + 'pthread_alloc.h', + 'rope', + 'rope.h', + 'ropeimpl.h', + 'set.h', + 'slist', + 'slist.h', + 'stack.h', + 'stdiostream.h', + 'stl_alloc.h', + 'stl_relops.h', + 'streambuf.h', + 'stream.h', + 'strfile.h', + 'strstream.h', + 'tempbuf.h', + 'tree.h', + 'type_traits.h', + 'vector.h', + # 17.6.1.2 C++ library headers + 'algorithm', + 'array', + 'atomic', + 'bitset', + 'chrono', + 'codecvt', + 'complex', + 'condition_variable', + 'deque', + 'exception', + 'forward_list', + 'fstream', + 'functional', + 'future', + 'initializer_list', + 'iomanip', + 'ios', + 'iosfwd', + 'iostream', + 'istream', + 'iterator', + 'limits', + 'list', + 'locale', + 'map', + 'memory', + 'mutex', + 'new', + 'numeric', + 'ostream', + 'queue', + 'random', + 'ratio', + 'regex', + 'scoped_allocator', + 'set', + 'sstream', + 'stack', + 'stdexcept', + 'streambuf', + 'string', + 'strstream', + 'system_error', + 'thread', + 'tuple', + 'typeindex', + 'typeinfo', + 'type_traits', + 'unordered_map', + 'unordered_set', + 'utility', + 'valarray', + 'vector', + # 17.6.1.2 C++14 headers + 'shared_mutex', + # 17.6.1.2 C++17 headers + 'any', + 'charconv', + 'codecvt', + 'execution', + 'filesystem', + 'memory_resource', + 'optional', + 'string_view', + 'variant', + # 17.6.1.2 C++ headers for C library facilities + 'cassert', + 'ccomplex', + 'cctype', + 'cerrno', + 'cfenv', + 'cfloat', + 'cinttypes', + 'ciso646', + 'climits', + 'clocale', + 'cmath', + 'csetjmp', + 'csignal', + 'cstdalign', + 'cstdarg', + 'cstdbool', + 'cstddef', + 'cstdint', + 'cstdio', + 'cstdlib', + 'cstring', + 'ctgmath', + 'ctime', + 'cuchar', + 'cwchar', + 'cwctype', + ]) + +# C headers +_C_HEADERS = frozenset([ + # System C headers + 'assert.h', + 'complex.h', + 'ctype.h', + 'errno.h', + 'fenv.h', + 'float.h', + 'inttypes.h', + 'iso646.h', + 'limits.h', + 'locale.h', + 'math.h', + 'setjmp.h', + 'signal.h', + 'stdalign.h', + 'stdarg.h', + 'stdatomic.h', + 'stdbool.h', + 'stddef.h', + 'stdint.h', + 'stdio.h', + 'stdlib.h', + 'stdnoreturn.h', + 'string.h', + 'tgmath.h', + 'threads.h', + 'time.h', + 'uchar.h', + 'wchar.h', + 'wctype.h', + # additional POSIX C headers + 'aio.h', + 'arpa/inet.h', + 'cpio.h', + 'dirent.h', + 'dlfcn.h', + 'fcntl.h', + 'fmtmsg.h', + 'fnmatch.h', + 'ftw.h', + 'glob.h', + 'grp.h', + 'iconv.h', + 'langinfo.h', + 'libgen.h', + 'monetary.h', + 'mqueue.h', + 'ndbm.h', + 'net/if.h', + 'netdb.h', + 'netinet/in.h', + 'netinet/tcp.h', + 'nl_types.h', + 'poll.h', + 'pthread.h', + 'pwd.h', + 'regex.h', + 'sched.h', + 'search.h', + 'semaphore.h', + 'setjmp.h', + 'signal.h', + 'spawn.h', + 'strings.h', + 'stropts.h', + 'syslog.h', + 'tar.h', + 'termios.h', + 'trace.h', + 'ulimit.h', + 'unistd.h', + 'utime.h', + 'utmpx.h', + 'wordexp.h', + # additional GNUlib headers + 'a.out.h', + 'aliases.h', + 'alloca.h', + 'ar.h', + 'argp.h', + 'argz.h', + 'byteswap.h', + 'crypt.h', + 'endian.h', + 'envz.h', + 'err.h', + 'error.h', + 'execinfo.h', + 'fpu_control.h', + 'fstab.h', + 'fts.h', + 'getopt.h', + 'gshadow.h', + 'ieee754.h', + 'ifaddrs.h', + 'libintl.h', + 'mcheck.h', + 'mntent.h', + 'obstack.h', + 'paths.h', + 'printf.h', + 'pty.h', + 'resolv.h', + 'shadow.h', + 'sysexits.h', + 'ttyent.h', + # Additional linux glibc headers + 'dlfcn.h', + 'elf.h', + 'features.h', + 'gconv.h', + 'gnu-versions.h', + 'lastlog.h', + 'libio.h', + 'link.h', + 'malloc.h', + 'memory.h', + 'netash/ash.h', + 'netatalk/at.h', + 'netax25/ax25.h', + 'neteconet/ec.h', + 'netipx/ipx.h', + 'netiucv/iucv.h', + 'netpacket/packet.h', + 'netrom/netrom.h', + 'netrose/rose.h', + 'nfs/nfs.h', + 'nl_types.h', + 'nss.h', + 're_comp.h', + 'regexp.h', + 'sched.h', + 'sgtty.h', + 'stab.h', + 'stdc-predef.h', + 'stdio_ext.h', + 'syscall.h', + 'termio.h', + 'thread_db.h', + 'ucontext.h', + 'ustat.h', + 'utmp.h', + 'values.h', + 'wait.h', + 'xlocale.h', + # Hardware specific headers + 'arm_neon.h', + 'emmintrin.h', + 'xmmintin.h', + ]) + +# Folders of C libraries so commonly used in C++, +# that they have parity with standard C libraries. +C_STANDARD_HEADER_FOLDERS = frozenset([ + # standard C library + "sys", + # glibc for linux + "arpa", + "asm-generic", + "bits", + "gnu", + "net", + "netinet", + "protocols", + "rpc", + "rpcsvc", + "scsi", + # linux kernel header + "drm", + "linux", + "misc", + "mtd", + "rdma", + "sound", + "video", + "xen", + ]) + +# Type names +_TYPES = re.compile( + r'^(?:' + # [dcl.type.simple] + r'(char(16_t|32_t)?)|wchar_t|' + r'bool|short|int|long|signed|unsigned|float|double|' + # [support.types] + r'(ptrdiff_t|size_t|max_align_t|nullptr_t)|' + # [cstdint.syn] + r'(u?int(_fast|_least)?(8|16|32|64)_t)|' + r'(u?int(max|ptr)_t)|' + r')$') + + +# These headers are excluded from [build/include] and [build/include_order] +# checks: +# - Anything not following google file name conventions (containing an +# uppercase character, such as Python.h or nsStringAPI.h, for example). +# - Lua headers. +_THIRD_PARTY_HEADERS_PATTERN = re.compile( + r'^(?:[^/]*[A-Z][^/]*\.h|lua\.h|lauxlib\.h|lualib\.h)$') + +# Pattern for matching FileInfo.BaseName() against test file name +_test_suffixes = ['_test', '_regtest', '_unittest'] +_TEST_FILE_SUFFIX = '(' + '|'.join(_test_suffixes) + r')$' + +# Pattern that matches only complete whitespace, possibly across multiple lines. +_EMPTY_CONDITIONAL_BODY_PATTERN = re.compile(r'^\s*$', re.DOTALL) + +# Assertion macros. These are defined in base/logging.h and +# testing/base/public/gunit.h. +_CHECK_MACROS = [ + 'DCHECK', 'CHECK', + 'EXPECT_TRUE', 'ASSERT_TRUE', + 'EXPECT_FALSE', 'ASSERT_FALSE', + ] + +# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE +_CHECK_REPLACEMENT = dict([(macro_var, {}) for macro_var in _CHECK_MACROS]) + +for op, replacement in [('==', 'EQ'), ('!=', 'NE'), + ('>=', 'GE'), ('>', 'GT'), + ('<=', 'LE'), ('<', 'LT')]: + _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement + _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement + _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement + _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement + +for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'), + ('>=', 'LT'), ('>', 'LE'), + ('<=', 'GT'), ('<', 'GE')]: + _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement + _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement + +# Alternative tokens and their replacements. For full list, see section 2.5 +# Alternative tokens [lex.digraph] in the C++ standard. +# +# Digraphs (such as '%:') are not included here since it's a mess to +# match those on a word boundary. +_ALT_TOKEN_REPLACEMENT = { + 'and': '&&', + 'bitor': '|', + 'or': '||', + 'xor': '^', + 'compl': '~', + 'bitand': '&', + 'and_eq': '&=', + 'or_eq': '|=', + 'xor_eq': '^=', + 'not': '!', + 'not_eq': '!=' + } + +# Compile regular expression that matches all the above keywords. The "[ =()]" +# bit is meant to avoid matching these keywords outside of boolean expressions. +# +# False positives include C-style multi-line comments and multi-line strings +# but those have always been troublesome for cpplint. +_ALT_TOKEN_REPLACEMENT_PATTERN = re.compile( + r'[ =()](' + ('|'.join(_ALT_TOKEN_REPLACEMENT.keys())) + r')(?=[ (]|$)') + + +# These constants define types of headers for use with +# _IncludeState.CheckNextIncludeOrder(). +_C_SYS_HEADER = 1 +_CPP_SYS_HEADER = 2 +_OTHER_SYS_HEADER = 3 +_LIKELY_MY_HEADER = 4 +_POSSIBLE_MY_HEADER = 5 +_OTHER_HEADER = 6 + +# These constants define the current inline assembly state +_NO_ASM = 0 # Outside of inline assembly block +_INSIDE_ASM = 1 # Inside inline assembly block +_END_ASM = 2 # Last line of inline assembly block +_BLOCK_ASM = 3 # The whole block is an inline assembly block + +# Match start of assembly blocks +_MATCH_ASM = re.compile(r'^\s*(?:asm|_asm|__asm|__asm__)' + r'(?:\s+(volatile|__volatile__))?' + r'\s*[{(]') + +# Match strings that indicate we're working on a C (not C++) file. +_SEARCH_C_FILE = re.compile(r'\b(?:LINT_C_FILE|' + r'vim?:\s*.*(\s*|:)filetype=c(\s*|:|$))') + +# Match string that indicates we're working on a Linux Kernel file. +_SEARCH_KERNEL_FILE = re.compile(r'\b(?:LINT_KERNEL_FILE)') + +# Commands for sed to fix the problem +_SED_FIXUPS = { + 'Remove spaces around =': r's/ = /=/', + 'Remove spaces around !=': r's/ != /!=/', + 'Remove space before ( in if (': r's/if (/if(/', + 'Remove space before ( in for (': r's/for (/for(/', + 'Remove space before ( in while (': r's/while (/while(/', + 'Remove space before ( in switch (': r's/switch (/switch(/', + 'Should have a space between // and comment': r's/\/\//\/\/ /', + 'Missing space before {': r's/\([^ ]\){/\1 {/', + 'Tab found, replace by spaces': r's/\t/ /g', + 'Line ends in whitespace. Consider deleting these extra spaces.': r's/\s*$//', + 'You don\'t need a ; after a }': r's/};/}/', + 'Missing space after ,': r's/,\([^ ]\)/, \1/g', +} + +_regexp_compile_cache = {} + +# {str, set(int)}: a map from error categories to sets of linenumbers +# on which those errors are expected and should be suppressed. +_error_suppressions = {} + +# The root directory used for deriving header guard CPP variable. +# This is set by --root flag. +_root = None +_root_debug = False + +# The top level repository directory. If set, _root is calculated relative to +# this directory instead of the directory containing version control artifacts. +# This is set by the --repository flag. +_repository = None + +# Files to exclude from linting. This is set by the --exclude flag. +_excludes = None + +# Whether to supress PrintInfo messages +_quiet = False + +# The allowed line length of files. +# This is set by --linelength flag. +_line_length = 80 + +# This allows to use different include order rule than default +_include_order = "default" + +try: + unicode +except NameError: + # -- pylint: disable=redefined-builtin + basestring = unicode = str + +try: + long +except NameError: + # -- pylint: disable=redefined-builtin + long = int + +if sys.version_info < (3,): + # -- pylint: disable=no-member + # BINARY_TYPE = str + itervalues = dict.itervalues + iteritems = dict.iteritems +else: + # BINARY_TYPE = bytes + itervalues = dict.values + iteritems = dict.items + +def unicode_escape_decode(x): + if sys.version_info < (3,): + return codecs.unicode_escape_decode(x)[0] + else: + return x + +# Treat all headers starting with 'h' equally: .h, .hpp, .hxx etc. +# This is set by --headers flag. +_hpp_headers = set([]) + +# {str, bool}: a map from error categories to booleans which indicate if the +# category should be suppressed for every line. +_global_error_suppressions = {} + +def ProcessHppHeadersOption(val): + global _hpp_headers + try: + _hpp_headers = {ext.strip() for ext in val.split(',')} + except ValueError: + PrintUsage('Header extensions must be comma separated list.') + +def ProcessIncludeOrderOption(val): + if val is None or val == "default": + pass + elif val == "standardcfirst": + global _include_order + _include_order = val + else: + PrintUsage('Invalid includeorder value %s. Expected default|standardcfirst') + +def IsHeaderExtension(file_extension): + return file_extension in GetHeaderExtensions() + +def GetHeaderExtensions(): + if _hpp_headers: + return _hpp_headers + if _valid_extensions: + return {h for h in _valid_extensions if 'h' in h} + return set(['h', 'hh', 'hpp', 'hxx', 'h++', 'cuh']) + +# The allowed extensions for file names +# This is set by --extensions flag +def GetAllExtensions(): + return GetHeaderExtensions().union(_valid_extensions or set( + ['c', 'cc', 'cpp', 'cxx', 'c++', 'cu'])) + +def ProcessExtensionsOption(val): + global _valid_extensions + try: + extensions = [ext.strip() for ext in val.split(',')] + _valid_extensions = set(extensions) + except ValueError: + PrintUsage('Extensions should be a comma-separated list of values;' + 'for example: extensions=hpp,cpp\n' + 'This could not be parsed: "%s"' % (val,)) + +def GetNonHeaderExtensions(): + return GetAllExtensions().difference(GetHeaderExtensions()) + +def ParseNolintSuppressions(filename, raw_line, linenum, error): + """Updates the global list of line error-suppressions. + + Parses any NOLINT comments on the current line, updating the global + error_suppressions store. Reports an error if the NOLINT comment + was malformed. + + Args: + filename: str, the name of the input file. + raw_line: str, the line of input text, with comments. + linenum: int, the number of the current line. + error: function, an error handler. + """ + matched = Search(r'\bNOLINT(NEXTLINE)?\b(\([^)]+\))?', raw_line) + if matched: + if matched.group(1): + suppressed_line = linenum + 1 + else: + suppressed_line = linenum + category = matched.group(2) + if category in (None, '(*)'): # => "suppress all" + _error_suppressions.setdefault(None, set()).add(suppressed_line) + else: + if category.startswith('(') and category.endswith(')'): + category = category[1:-1] + if category in _ERROR_CATEGORIES: + _error_suppressions.setdefault(category, set()).add(suppressed_line) + elif category not in _LEGACY_ERROR_CATEGORIES: + error(filename, linenum, 'readability/nolint', 5, + 'Unknown NOLINT error category: %s' % category) + + +def ProcessGlobalSuppresions(lines): + """Updates the list of global error suppressions. + + Parses any lint directives in the file that have global effect. + + Args: + lines: An array of strings, each representing a line of the file, with the + last element being empty if the file is terminated with a newline. + """ + for line in lines: + if _SEARCH_C_FILE.search(line): + for category in _DEFAULT_C_SUPPRESSED_CATEGORIES: + _global_error_suppressions[category] = True + if _SEARCH_KERNEL_FILE.search(line): + for category in _DEFAULT_KERNEL_SUPPRESSED_CATEGORIES: + _global_error_suppressions[category] = True + + +def ResetNolintSuppressions(): + """Resets the set of NOLINT suppressions to empty.""" + _error_suppressions.clear() + _global_error_suppressions.clear() + + +def IsErrorSuppressedByNolint(category, linenum): + """Returns true if the specified error category is suppressed on this line. + + Consults the global error_suppressions map populated by + ParseNolintSuppressions/ProcessGlobalSuppresions/ResetNolintSuppressions. + + Args: + category: str, the category of the error. + linenum: int, the current line number. + Returns: + bool, True iff the error should be suppressed due to a NOLINT comment or + global suppression. + """ + return (_global_error_suppressions.get(category, False) or + linenum in _error_suppressions.get(category, set()) or + linenum in _error_suppressions.get(None, set())) + + +def Match(pattern, s): + """Matches the string with the pattern, caching the compiled regexp.""" + # The regexp compilation caching is inlined in both Match and Search for + # performance reasons; factoring it out into a separate function turns out + # to be noticeably expensive. + if pattern not in _regexp_compile_cache: + _regexp_compile_cache[pattern] = sre_compile.compile(pattern) + return _regexp_compile_cache[pattern].match(s) + + +def ReplaceAll(pattern, rep, s): + """Replaces instances of pattern in a string with a replacement. + + The compiled regex is kept in a cache shared by Match and Search. + + Args: + pattern: regex pattern + rep: replacement text + s: search string + + Returns: + string with replacements made (or original string if no replacements) + """ + if pattern not in _regexp_compile_cache: + _regexp_compile_cache[pattern] = sre_compile.compile(pattern) + return _regexp_compile_cache[pattern].sub(rep, s) + + +def Search(pattern, s): + """Searches the string for the pattern, caching the compiled regexp.""" + if pattern not in _regexp_compile_cache: + _regexp_compile_cache[pattern] = sre_compile.compile(pattern) + return _regexp_compile_cache[pattern].search(s) + + +def _IsSourceExtension(s): + """File extension (excluding dot) matches a source file extension.""" + return s in GetNonHeaderExtensions() + + +class _IncludeState(object): + """Tracks line numbers for includes, and the order in which includes appear. + + include_list contains list of lists of (header, line number) pairs. + It's a lists of lists rather than just one flat list to make it + easier to update across preprocessor boundaries. + + Call CheckNextIncludeOrder() once for each header in the file, passing + in the type constants defined above. Calls in an illegal order will + raise an _IncludeError with an appropriate error message. + + """ + # self._section will move monotonically through this set. If it ever + # needs to move backwards, CheckNextIncludeOrder will raise an error. + _INITIAL_SECTION = 0 + _MY_H_SECTION = 1 + _C_SECTION = 2 + _CPP_SECTION = 3 + _OTHER_SYS_SECTION = 4 + _OTHER_H_SECTION = 5 + + _TYPE_NAMES = { + _C_SYS_HEADER: 'C system header', + _CPP_SYS_HEADER: 'C++ system header', + _OTHER_SYS_HEADER: 'other system header', + _LIKELY_MY_HEADER: 'header this file implements', + _POSSIBLE_MY_HEADER: 'header this file may implement', + _OTHER_HEADER: 'other header', + } + _SECTION_NAMES = { + _INITIAL_SECTION: "... nothing. (This can't be an error.)", + _MY_H_SECTION: 'a header this file implements', + _C_SECTION: 'C system header', + _CPP_SECTION: 'C++ system header', + _OTHER_SYS_SECTION: 'other system header', + _OTHER_H_SECTION: 'other header', + } + + def __init__(self): + self.include_list = [[]] + self._section = None + self._last_header = None + self.ResetSection('') + + def FindHeader(self, header): + """Check if a header has already been included. + + Args: + header: header to check. + Returns: + Line number of previous occurrence, or -1 if the header has not + been seen before. + """ + for section_list in self.include_list: + for f in section_list: + if f[0] == header: + return f[1] + return -1 + + def ResetSection(self, directive): + """Reset section checking for preprocessor directive. + + Args: + directive: preprocessor directive (e.g. "if", "else"). + """ + # The name of the current section. + self._section = self._INITIAL_SECTION + # The path of last found header. + self._last_header = '' + + # Update list of includes. Note that we never pop from the + # include list. + if directive in ('if', 'ifdef', 'ifndef'): + self.include_list.append([]) + elif directive in ('else', 'elif'): + self.include_list[-1] = [] + + def SetLastHeader(self, header_path): + self._last_header = header_path + + def CanonicalizeAlphabeticalOrder(self, header_path): + """Returns a path canonicalized for alphabetical comparison. + + - replaces "-" with "_" so they both cmp the same. + - removes '-inl' since we don't require them to be after the main header. + - lowercase everything, just in case. + + Args: + header_path: Path to be canonicalized. + + Returns: + Canonicalized path. + """ + return header_path.replace('-inl.h', '.h').replace('-', '_').lower() + + def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path): + """Check if a header is in alphabetical order with the previous header. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + header_path: Canonicalized header to be checked. + + Returns: + Returns true if the header is in alphabetical order. + """ + # If previous section is different from current section, _last_header will + # be reset to empty string, so it's always less than current header. + # + # If previous line was a blank line, assume that the headers are + # intentionally sorted the way they are. + if (self._last_header > header_path and + Match(r'^\s*#\s*include\b', clean_lines.elided[linenum - 1])): + return False + return True + + def CheckNextIncludeOrder(self, header_type): + """Returns a non-empty error message if the next header is out of order. + + This function also updates the internal state to be ready to check + the next include. + + Args: + header_type: One of the _XXX_HEADER constants defined above. + + Returns: + The empty string if the header is in the right order, or an + error message describing what's wrong. + + """ + error_message = ('Found %s after %s' % + (self._TYPE_NAMES[header_type], + self._SECTION_NAMES[self._section])) + + last_section = self._section + + if header_type == _C_SYS_HEADER: + if self._section <= self._C_SECTION: + self._section = self._C_SECTION + else: + self._last_header = '' + return error_message + elif header_type == _CPP_SYS_HEADER: + if self._section <= self._CPP_SECTION: + self._section = self._CPP_SECTION + else: + self._last_header = '' + return error_message + elif header_type == _OTHER_SYS_HEADER: + if self._section <= self._OTHER_SYS_SECTION: + self._section = self._OTHER_SYS_SECTION + else: + self._last_header = '' + return error_message + elif header_type == _LIKELY_MY_HEADER: + if self._section <= self._MY_H_SECTION: + self._section = self._MY_H_SECTION + else: + self._section = self._OTHER_H_SECTION + elif header_type == _POSSIBLE_MY_HEADER: + if self._section <= self._MY_H_SECTION: + self._section = self._MY_H_SECTION + else: + # This will always be the fallback because we're not sure + # enough that the header is associated with this file. + self._section = self._OTHER_H_SECTION + else: + assert header_type == _OTHER_HEADER + self._section = self._OTHER_H_SECTION + + if last_section != self._section: + self._last_header = '' + + return '' + + +class _CppLintState(object): + """Maintains module-wide state..""" + + def __init__(self): + self.verbose_level = 1 # global setting. + self.error_count = 0 # global count of reported errors + # filters to apply when emitting error messages + self.filters = _DEFAULT_FILTERS[:] + # backup of filter list. Used to restore the state after each file. + self._filters_backup = self.filters[:] + self.counting = 'total' # In what way are we counting errors? + self.errors_by_category = {} # string to int dict storing error counts + self.quiet = False # Suppress non-error messagess? + + # output format: + # "emacs" - format that emacs can parse (default) + # "eclipse" - format that eclipse can parse + # "vs7" - format that Microsoft Visual Studio 7 can parse + # "junit" - format that Jenkins, Bamboo, etc can parse + # "sed" - returns a gnu sed command to fix the problem + # "gsed" - like sed, but names the command gsed, e.g. for macOS homebrew users + self.output_format = 'emacs' + + # For JUnit output, save errors and failures until the end so that they + # can be written into the XML + self._junit_errors = [] + self._junit_failures = [] + + def SetOutputFormat(self, output_format): + """Sets the output format for errors.""" + self.output_format = output_format + + def SetQuiet(self, quiet): + """Sets the module's quiet settings, and returns the previous setting.""" + last_quiet = self.quiet + self.quiet = quiet + return last_quiet + + def SetVerboseLevel(self, level): + """Sets the module's verbosity, and returns the previous setting.""" + last_verbose_level = self.verbose_level + self.verbose_level = level + return last_verbose_level + + def SetCountingStyle(self, counting_style): + """Sets the module's counting options.""" + self.counting = counting_style + + def SetFilters(self, filters): + """Sets the error-message filters. + + These filters are applied when deciding whether to emit a given + error message. + + Args: + filters: A string of comma-separated filters (eg "+whitespace/indent"). + Each filter should start with + or -; else we die. + + Raises: + ValueError: The comma-separated filters did not all start with '+' or '-'. + E.g. "-,+whitespace,-whitespace/indent,whitespace/badfilter" + """ + # Default filters always have less priority than the flag ones. + self.filters = _DEFAULT_FILTERS[:] + self.AddFilters(filters) + + def AddFilters(self, filters): + """ Adds more filters to the existing list of error-message filters. """ + for filt in filters.split(','): + clean_filt = filt.strip() + if clean_filt: + self.filters.append(clean_filt) + for filt in self.filters: + if not (filt.startswith('+') or filt.startswith('-')): + raise ValueError('Every filter in --filters must start with + or -' + ' (%s does not)' % filt) + + def BackupFilters(self): + """ Saves the current filter list to backup storage.""" + self._filters_backup = self.filters[:] + + def RestoreFilters(self): + """ Restores filters previously backed up.""" + self.filters = self._filters_backup[:] + + def ResetErrorCounts(self): + """Sets the module's error statistic back to zero.""" + self.error_count = 0 + self.errors_by_category = {} + + def IncrementErrorCount(self, category): + """Bumps the module's error statistic.""" + self.error_count += 1 + if self.counting in ('toplevel', 'detailed'): + if self.counting != 'detailed': + category = category.split('/')[0] + if category not in self.errors_by_category: + self.errors_by_category[category] = 0 + self.errors_by_category[category] += 1 + + def PrintErrorCounts(self): + """Print a summary of errors by category, and the total.""" + for category, count in sorted(iteritems(self.errors_by_category)): + self.PrintInfo('Category \'%s\' errors found: %d\n' % + (category, count)) + if self.error_count > 0: + self.PrintInfo('Total errors found: %d\n' % self.error_count) + + def PrintInfo(self, message): + if not _quiet and self.output_format != 'junit': + sys.stdout.write(message) + + def PrintError(self, message): + if self.output_format == 'junit': + self._junit_errors.append(message) + else: + sys.stderr.write(message) + + def AddJUnitFailure(self, filename, linenum, message, category, confidence): + self._junit_failures.append((filename, linenum, message, category, + confidence)) + + def FormatJUnitXML(self): + num_errors = len(self._junit_errors) + num_failures = len(self._junit_failures) + + testsuite = xml.etree.ElementTree.Element('testsuite') + testsuite.attrib['errors'] = str(num_errors) + testsuite.attrib['failures'] = str(num_failures) + testsuite.attrib['name'] = 'cpplint' + + if num_errors == 0 and num_failures == 0: + testsuite.attrib['tests'] = str(1) + xml.etree.ElementTree.SubElement(testsuite, 'testcase', name='passed') + + else: + testsuite.attrib['tests'] = str(num_errors + num_failures) + if num_errors > 0: + testcase = xml.etree.ElementTree.SubElement(testsuite, 'testcase') + testcase.attrib['name'] = 'errors' + error = xml.etree.ElementTree.SubElement(testcase, 'error') + error.text = '\n'.join(self._junit_errors) + if num_failures > 0: + # Group failures by file + failed_file_order = [] + failures_by_file = {} + for failure in self._junit_failures: + failed_file = failure[0] + if failed_file not in failed_file_order: + failed_file_order.append(failed_file) + failures_by_file[failed_file] = [] + failures_by_file[failed_file].append(failure) + # Create a testcase for each file + for failed_file in failed_file_order: + failures = failures_by_file[failed_file] + testcase = xml.etree.ElementTree.SubElement(testsuite, 'testcase') + testcase.attrib['name'] = failed_file + failure = xml.etree.ElementTree.SubElement(testcase, 'failure') + template = '{0}: {1} [{2}] [{3}]' + texts = [template.format(f[1], f[2], f[3], f[4]) for f in failures] + failure.text = '\n'.join(texts) + + xml_decl = '\n' + return xml_decl + xml.etree.ElementTree.tostring(testsuite, 'utf-8').decode('utf-8') + + +_cpplint_state = _CppLintState() + + +def _OutputFormat(): + """Gets the module's output format.""" + return _cpplint_state.output_format + + +def _SetOutputFormat(output_format): + """Sets the module's output format.""" + _cpplint_state.SetOutputFormat(output_format) + +def _Quiet(): + """Return's the module's quiet setting.""" + return _cpplint_state.quiet + +def _SetQuiet(quiet): + """Set the module's quiet status, and return previous setting.""" + return _cpplint_state.SetQuiet(quiet) + + +def _VerboseLevel(): + """Returns the module's verbosity setting.""" + return _cpplint_state.verbose_level + + +def _SetVerboseLevel(level): + """Sets the module's verbosity, and returns the previous setting.""" + return _cpplint_state.SetVerboseLevel(level) + + +def _SetCountingStyle(level): + """Sets the module's counting options.""" + _cpplint_state.SetCountingStyle(level) + + +def _Filters(): + """Returns the module's list of output filters, as a list.""" + return _cpplint_state.filters + + +def _SetFilters(filters): + """Sets the module's error-message filters. + + These filters are applied when deciding whether to emit a given + error message. + + Args: + filters: A string of comma-separated filters (eg "whitespace/indent"). + Each filter should start with + or -; else we die. + """ + _cpplint_state.SetFilters(filters) + +def _AddFilters(filters): + """Adds more filter overrides. + + Unlike _SetFilters, this function does not reset the current list of filters + available. + + Args: + filters: A string of comma-separated filters (eg "whitespace/indent"). + Each filter should start with + or -; else we die. + """ + _cpplint_state.AddFilters(filters) + +def _BackupFilters(): + """ Saves the current filter list to backup storage.""" + _cpplint_state.BackupFilters() + +def _RestoreFilters(): + """ Restores filters previously backed up.""" + _cpplint_state.RestoreFilters() + +class _FunctionState(object): + """Tracks current function name and the number of lines in its body.""" + + _NORMAL_TRIGGER = 250 # for --v=0, 500 for --v=1, etc. + _TEST_TRIGGER = 400 # about 50% more than _NORMAL_TRIGGER. + + def __init__(self): + self.in_a_function = False + self.lines_in_function = 0 + self.current_function = '' + + def Begin(self, function_name): + """Start analyzing function body. + + Args: + function_name: The name of the function being tracked. + """ + self.in_a_function = True + self.lines_in_function = 0 + self.current_function = function_name + + def Count(self): + """Count line in current function body.""" + if self.in_a_function: + self.lines_in_function += 1 + + def Check(self, error, filename, linenum): + """Report if too many lines in function body. + + Args: + error: The function to call with any errors found. + filename: The name of the current file. + linenum: The number of the line to check. + """ + if not self.in_a_function: + return + + if Match(r'T(EST|est)', self.current_function): + base_trigger = self._TEST_TRIGGER + else: + base_trigger = self._NORMAL_TRIGGER + trigger = base_trigger * 2**_VerboseLevel() + + if self.lines_in_function > trigger: + error_level = int(math.log(self.lines_in_function / base_trigger, 2)) + # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ... + if error_level > 5: + error_level = 5 + error(filename, linenum, 'readability/fn_size', error_level, + 'Small and focused functions are preferred:' + ' %s has %d non-comment lines' + ' (error triggered by exceeding %d lines).' % ( + self.current_function, self.lines_in_function, trigger)) + + def End(self): + """Stop analyzing function body.""" + self.in_a_function = False + + +class _IncludeError(Exception): + """Indicates a problem with the include order in a file.""" + pass + + +class FileInfo(object): + """Provides utility functions for filenames. + + FileInfo provides easy access to the components of a file's path + relative to the project root. + """ + + def __init__(self, filename): + self._filename = filename + + def FullName(self): + """Make Windows paths like Unix.""" + return os.path.abspath(self._filename).replace('\\', '/') + + def RepositoryName(self): + r"""FullName after removing the local path to the repository. + + If we have a real absolute path name here we can try to do something smart: + detecting the root of the checkout and truncating /path/to/checkout from + the name so that we get header guards that don't include things like + "C:\\Documents and Settings\\..." or "/home/username/..." in them and thus + people on different computers who have checked the source out to different + locations won't see bogus errors. + """ + fullname = self.FullName() + + if os.path.exists(fullname): + project_dir = os.path.dirname(fullname) + + # If the user specified a repository path, it exists, and the file is + # contained in it, use the specified repository path + if _repository: + repo = FileInfo(_repository).FullName() + root_dir = project_dir + while os.path.exists(root_dir): + # allow case insensitive compare on Windows + if os.path.normcase(root_dir) == os.path.normcase(repo): + return os.path.relpath(fullname, root_dir).replace('\\', '/') + one_up_dir = os.path.dirname(root_dir) + if one_up_dir == root_dir: + break + root_dir = one_up_dir + + if os.path.exists(os.path.join(project_dir, ".svn")): + # If there's a .svn file in the current directory, we recursively look + # up the directory tree for the top of the SVN checkout + root_dir = project_dir + one_up_dir = os.path.dirname(root_dir) + while os.path.exists(os.path.join(one_up_dir, ".svn")): + root_dir = os.path.dirname(root_dir) + one_up_dir = os.path.dirname(one_up_dir) + + prefix = os.path.commonprefix([root_dir, project_dir]) + return fullname[len(prefix) + 1:] + + # Not SVN <= 1.6? Try to find a git, hg, or svn top level directory by + # searching up from the current path. + root_dir = current_dir = os.path.dirname(fullname) + while current_dir != os.path.dirname(current_dir): + if (os.path.exists(os.path.join(current_dir, ".git")) or + os.path.exists(os.path.join(current_dir, ".hg")) or + os.path.exists(os.path.join(current_dir, ".svn"))): + root_dir = current_dir + current_dir = os.path.dirname(current_dir) + + if (os.path.exists(os.path.join(root_dir, ".git")) or + os.path.exists(os.path.join(root_dir, ".hg")) or + os.path.exists(os.path.join(root_dir, ".svn"))): + prefix = os.path.commonprefix([root_dir, project_dir]) + return fullname[len(prefix) + 1:] + + # Don't know what to do; header guard warnings may be wrong... + return fullname + + def Split(self): + """Splits the file into the directory, basename, and extension. + + For 'chrome/browser/browser.cc', Split() would + return ('chrome/browser', 'browser', '.cc') + + Returns: + A tuple of (directory, basename, extension). + """ + + googlename = self.RepositoryName() + project, rest = os.path.split(googlename) + return (project,) + os.path.splitext(rest) + + def BaseName(self): + """File base name - text after the final slash, before the final period.""" + return self.Split()[1] + + def Extension(self): + """File extension - text following the final period, includes that period.""" + return self.Split()[2] + + def NoExtension(self): + """File has no source file extension.""" + return '/'.join(self.Split()[0:2]) + + def IsSource(self): + """File has a source file extension.""" + return _IsSourceExtension(self.Extension()[1:]) + + +def _ShouldPrintError(category, confidence, linenum): + """If confidence >= verbose, category passes filter and is not suppressed.""" + + # There are three ways we might decide not to print an error message: + # a "NOLINT(category)" comment appears in the source, + # the verbosity level isn't high enough, or the filters filter it out. + if IsErrorSuppressedByNolint(category, linenum): + return False + + if confidence < _cpplint_state.verbose_level: + return False + + is_filtered = False + for one_filter in _Filters(): + if one_filter.startswith('-'): + if category.startswith(one_filter[1:]): + is_filtered = True + elif one_filter.startswith('+'): + if category.startswith(one_filter[1:]): + is_filtered = False + else: + assert False # should have been checked for in SetFilter. + if is_filtered: + return False + + return True + + +def Error(filename, linenum, category, confidence, message): + """Logs the fact we've found a lint error. + + We log where the error was found, and also our confidence in the error, + that is, how certain we are this is a legitimate style regression, and + not a misidentification or a use that's sometimes justified. + + False positives can be suppressed by the use of + "cpplint(category)" comments on the offending line. These are + parsed into _error_suppressions. + + Args: + filename: The name of the file containing the error. + linenum: The number of the line containing the error. + category: A string used to describe the "category" this bug + falls under: "whitespace", say, or "runtime". Categories + may have a hierarchy separated by slashes: "whitespace/indent". + confidence: A number from 1-5 representing a confidence score for + the error, with 5 meaning that we are certain of the problem, + and 1 meaning that it could be a legitimate construct. + message: The error message. + """ + if _ShouldPrintError(category, confidence, linenum): + _cpplint_state.IncrementErrorCount(category) + if _cpplint_state.output_format == 'vs7': + _cpplint_state.PrintError('%s(%s): error cpplint: [%s] %s [%d]\n' % ( + filename, linenum, category, message, confidence)) + elif _cpplint_state.output_format == 'eclipse': + sys.stderr.write('%s:%s: warning: %s [%s] [%d]\n' % ( + filename, linenum, message, category, confidence)) + elif _cpplint_state.output_format == 'junit': + _cpplint_state.AddJUnitFailure(filename, linenum, message, category, + confidence) + elif _cpplint_state.output_format in ['sed', 'gsed']: + if message in _SED_FIXUPS: + sys.stdout.write(_cpplint_state.output_format + " -i '%s%s' %s # %s [%s] [%d]\n" % ( + linenum, _SED_FIXUPS[message], filename, message, category, confidence)) + else: + sys.stderr.write('# %s:%s: "%s" [%s] [%d]\n' % ( + filename, linenum, message, category, confidence)) + else: + final_message = '%s:%s: %s [%s] [%d]\n' % ( + filename, linenum, message, category, confidence) + sys.stderr.write(final_message) + +# Matches standard C++ escape sequences per 2.13.2.3 of the C++ standard. +_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile( + r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)') +# Match a single C style comment on the same line. +_RE_PATTERN_C_COMMENTS = r'/\*(?:[^*]|\*(?!/))*\*/' +# Matches multi-line C style comments. +# This RE is a little bit more complicated than one might expect, because we +# have to take care of space removals tools so we can handle comments inside +# statements better. +# The current rule is: We only clear spaces from both sides when we're at the +# end of the line. Otherwise, we try to remove spaces from the right side, +# if this doesn't work we try on left side but only if there's a non-character +# on the right. +_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile( + r'(\s*' + _RE_PATTERN_C_COMMENTS + r'\s*$|' + + _RE_PATTERN_C_COMMENTS + r'\s+|' + + r'\s+' + _RE_PATTERN_C_COMMENTS + r'(?=\W)|' + + _RE_PATTERN_C_COMMENTS + r')') + + +def IsCppString(line): + """Does line terminate so, that the next symbol is in string constant. + + This function does not consider single-line nor multi-line comments. + + Args: + line: is a partial line of code starting from the 0..n. + + Returns: + True, if next character appended to 'line' is inside a + string constant. + """ + + line = line.replace(r'\\', 'XX') # after this, \\" does not match to \" + return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1 + + +def CleanseRawStrings(raw_lines): + """Removes C++11 raw strings from lines. + + Before: + static const char kData[] = R"( + multi-line string + )"; + + After: + static const char kData[] = "" + (replaced by blank line) + ""; + + Args: + raw_lines: list of raw lines. + + Returns: + list of lines with C++11 raw strings replaced by empty strings. + """ + + delimiter = None + lines_without_raw_strings = [] + for line in raw_lines: + if delimiter: + # Inside a raw string, look for the end + end = line.find(delimiter) + if end >= 0: + # Found the end of the string, match leading space for this + # line and resume copying the original lines, and also insert + # a "" on the last line. + leading_space = Match(r'^(\s*)\S', line) + line = leading_space.group(1) + '""' + line[end + len(delimiter):] + delimiter = None + else: + # Haven't found the end yet, append a blank line. + line = '""' + + # Look for beginning of a raw string, and replace them with + # empty strings. This is done in a loop to handle multiple raw + # strings on the same line. + while delimiter is None: + # Look for beginning of a raw string. + # See 2.14.15 [lex.string] for syntax. + # + # Once we have matched a raw string, we check the prefix of the + # line to make sure that the line is not part of a single line + # comment. It's done this way because we remove raw strings + # before removing comments as opposed to removing comments + # before removing raw strings. This is because there are some + # cpplint checks that requires the comments to be preserved, but + # we don't want to check comments that are inside raw strings. + matched = Match(r'^(.*?)\b(?:R|u8R|uR|UR|LR)"([^\s\\()]*)\((.*)$', line) + if (matched and + not Match(r'^([^\'"]|\'(\\.|[^\'])*\'|"(\\.|[^"])*")*//', + matched.group(1))): + delimiter = ')' + matched.group(2) + '"' + + end = matched.group(3).find(delimiter) + if end >= 0: + # Raw string ended on same line + line = (matched.group(1) + '""' + + matched.group(3)[end + len(delimiter):]) + delimiter = None + else: + # Start of a multi-line raw string + line = matched.group(1) + '""' + else: + break + + lines_without_raw_strings.append(line) + + # TODO(unknown): if delimiter is not None here, we might want to + # emit a warning for unterminated string. + return lines_without_raw_strings + + +def FindNextMultiLineCommentStart(lines, lineix): + """Find the beginning marker for a multiline comment.""" + while lineix < len(lines): + if lines[lineix].strip().startswith('/*'): + # Only return this marker if the comment goes beyond this line + if lines[lineix].strip().find('*/', 2) < 0: + return lineix + lineix += 1 + return len(lines) + + +def FindNextMultiLineCommentEnd(lines, lineix): + """We are inside a comment, find the end marker.""" + while lineix < len(lines): + if lines[lineix].strip().endswith('*/'): + return lineix + lineix += 1 + return len(lines) + + +def RemoveMultiLineCommentsFromRange(lines, begin, end): + """Clears a range of lines for multi-line comments.""" + # Having // dummy comments makes the lines non-empty, so we will not get + # unnecessary blank line warnings later in the code. + for i in range(begin, end): + lines[i] = '/**/' + + +def RemoveMultiLineComments(filename, lines, error): + """Removes multiline (c-style) comments from lines.""" + lineix = 0 + while lineix < len(lines): + lineix_begin = FindNextMultiLineCommentStart(lines, lineix) + if lineix_begin >= len(lines): + return + lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin) + if lineix_end >= len(lines): + error(filename, lineix_begin + 1, 'readability/multiline_comment', 5, + 'Could not find end of multi-line comment') + return + RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + 1) + lineix = lineix_end + 1 + + +def CleanseComments(line): + """Removes //-comments and single-line C-style /* */ comments. + + Args: + line: A line of C++ source. + + Returns: + The line with single-line comments removed. + """ + commentpos = line.find('//') + if commentpos != -1 and not IsCppString(line[:commentpos]): + line = line[:commentpos].rstrip() + # get rid of /* ... */ + return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line) + + +class CleansedLines(object): + """Holds 4 copies of all lines with different preprocessing applied to them. + + 1) elided member contains lines without strings and comments. + 2) lines member contains lines without comments. + 3) raw_lines member contains all the lines without processing. + 4) lines_without_raw_strings member is same as raw_lines, but with C++11 raw + strings removed. + All these members are of , and of the same length. + """ + + def __init__(self, lines): + self.elided = [] + self.lines = [] + self.raw_lines = lines + self.num_lines = len(lines) + self.lines_without_raw_strings = CleanseRawStrings(lines) + for linenum in range(len(self.lines_without_raw_strings)): + self.lines.append(CleanseComments( + self.lines_without_raw_strings[linenum])) + elided = self._CollapseStrings(self.lines_without_raw_strings[linenum]) + self.elided.append(CleanseComments(elided)) + + def NumLines(self): + """Returns the number of lines represented.""" + return self.num_lines + + @staticmethod + def _CollapseStrings(elided): + """Collapses strings and chars on a line to simple "" or '' blocks. + + We nix strings first so we're not fooled by text like '"http://"' + + Args: + elided: The line being processed. + + Returns: + The line with collapsed strings. + """ + if _RE_PATTERN_INCLUDE.match(elided): + return elided + + # Remove escaped characters first to make quote/single quote collapsing + # basic. Things that look like escaped characters shouldn't occur + # outside of strings and chars. + elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided) + + # Replace quoted strings and digit separators. Both single quotes + # and double quotes are processed in the same loop, otherwise + # nested quotes wouldn't work. + collapsed = '' + while True: + # Find the first quote character + match = Match(r'^([^\'"]*)([\'"])(.*)$', elided) + if not match: + collapsed += elided + break + head, quote, tail = match.groups() + + if quote == '"': + # Collapse double quoted strings + second_quote = tail.find('"') + if second_quote >= 0: + collapsed += head + '""' + elided = tail[second_quote + 1:] + else: + # Unmatched double quote, don't bother processing the rest + # of the line since this is probably a multiline string. + collapsed += elided + break + else: + # Found single quote, check nearby text to eliminate digit separators. + # + # There is no special handling for floating point here, because + # the integer/fractional/exponent parts would all be parsed + # correctly as long as there are digits on both sides of the + # separator. So we are fine as long as we don't see something + # like "0.'3" (gcc 4.9.0 will not allow this literal). + if Search(r'\b(?:0[bBxX]?|[1-9])[0-9a-fA-F]*$', head): + match_literal = Match(r'^((?:\'?[0-9a-zA-Z_])*)(.*)$', "'" + tail) + collapsed += head + match_literal.group(1).replace("'", '') + elided = match_literal.group(2) + else: + second_quote = tail.find('\'') + if second_quote >= 0: + collapsed += head + "''" + elided = tail[second_quote + 1:] + else: + # Unmatched single quote + collapsed += elided + break + + return collapsed + + +def FindEndOfExpressionInLine(line, startpos, stack): + """Find the position just after the end of current parenthesized expression. + + Args: + line: a CleansedLines line. + startpos: start searching at this position. + stack: nesting stack at startpos. + + Returns: + On finding matching end: (index just after matching end, None) + On finding an unclosed expression: (-1, None) + Otherwise: (-1, new stack at end of this line) + """ + for i in xrange(startpos, len(line)): + char = line[i] + if char in '([{': + # Found start of parenthesized expression, push to expression stack + stack.append(char) + elif char == '<': + # Found potential start of template argument list + if i > 0 and line[i - 1] == '<': + # Left shift operator + if stack and stack[-1] == '<': + stack.pop() + if not stack: + return (-1, None) + elif i > 0 and Search(r'\boperator\s*$', line[0:i]): + # operator<, don't add to stack + continue + else: + # Tentative start of template argument list + stack.append('<') + elif char in ')]}': + # Found end of parenthesized expression. + # + # If we are currently expecting a matching '>', the pending '<' + # must have been an operator. Remove them from expression stack. + while stack and stack[-1] == '<': + stack.pop() + if not stack: + return (-1, None) + if ((stack[-1] == '(' and char == ')') or + (stack[-1] == '[' and char == ']') or + (stack[-1] == '{' and char == '}')): + stack.pop() + if not stack: + return (i + 1, None) + else: + # Mismatched parentheses + return (-1, None) + elif char == '>': + # Found potential end of template argument list. + + # Ignore "->" and operator functions + if (i > 0 and + (line[i - 1] == '-' or Search(r'\boperator\s*$', line[0:i - 1]))): + continue + + # Pop the stack if there is a matching '<'. Otherwise, ignore + # this '>' since it must be an operator. + if stack: + if stack[-1] == '<': + stack.pop() + if not stack: + return (i + 1, None) + elif char == ';': + # Found something that look like end of statements. If we are currently + # expecting a '>', the matching '<' must have been an operator, since + # template argument list should not contain statements. + while stack and stack[-1] == '<': + stack.pop() + if not stack: + return (-1, None) + + # Did not find end of expression or unbalanced parentheses on this line + return (-1, stack) + + +def CloseExpression(clean_lines, linenum, pos): + """If input points to ( or { or [ or <, finds the position that closes it. + + If lines[linenum][pos] points to a '(' or '{' or '[' or '<', finds the + linenum/pos that correspond to the closing of the expression. + + TODO(unknown): cpplint spends a fair bit of time matching parentheses. + Ideally we would want to index all opening and closing parentheses once + and have CloseExpression be just a simple lookup, but due to preprocessor + tricks, this is not so easy. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + pos: A position on the line. + + Returns: + A tuple (line, linenum, pos) pointer *past* the closing brace, or + (line, len(lines), -1) if we never find a close. Note we ignore + strings and comments when matching; and the line we return is the + 'cleansed' line at linenum. + """ + + line = clean_lines.elided[linenum] + if (line[pos] not in '({[<') or Match(r'<[<=]', line[pos:]): + return (line, clean_lines.NumLines(), -1) + + # Check first line + (end_pos, stack) = FindEndOfExpressionInLine(line, pos, []) + if end_pos > -1: + return (line, linenum, end_pos) + + # Continue scanning forward + while stack and linenum < clean_lines.NumLines() - 1: + linenum += 1 + line = clean_lines.elided[linenum] + (end_pos, stack) = FindEndOfExpressionInLine(line, 0, stack) + if end_pos > -1: + return (line, linenum, end_pos) + + # Did not find end of expression before end of file, give up + return (line, clean_lines.NumLines(), -1) + + +def FindStartOfExpressionInLine(line, endpos, stack): + """Find position at the matching start of current expression. + + This is almost the reverse of FindEndOfExpressionInLine, but note + that the input position and returned position differs by 1. + + Args: + line: a CleansedLines line. + endpos: start searching at this position. + stack: nesting stack at endpos. + + Returns: + On finding matching start: (index at matching start, None) + On finding an unclosed expression: (-1, None) + Otherwise: (-1, new stack at beginning of this line) + """ + i = endpos + while i >= 0: + char = line[i] + if char in ')]}': + # Found end of expression, push to expression stack + stack.append(char) + elif char == '>': + # Found potential end of template argument list. + # + # Ignore it if it's a "->" or ">=" or "operator>" + if (i > 0 and + (line[i - 1] == '-' or + Match(r'\s>=\s', line[i - 1:]) or + Search(r'\boperator\s*$', line[0:i]))): + i -= 1 + else: + stack.append('>') + elif char == '<': + # Found potential start of template argument list + if i > 0 and line[i - 1] == '<': + # Left shift operator + i -= 1 + else: + # If there is a matching '>', we can pop the expression stack. + # Otherwise, ignore this '<' since it must be an operator. + if stack and stack[-1] == '>': + stack.pop() + if not stack: + return (i, None) + elif char in '([{': + # Found start of expression. + # + # If there are any unmatched '>' on the stack, they must be + # operators. Remove those. + while stack and stack[-1] == '>': + stack.pop() + if not stack: + return (-1, None) + if ((char == '(' and stack[-1] == ')') or + (char == '[' and stack[-1] == ']') or + (char == '{' and stack[-1] == '}')): + stack.pop() + if not stack: + return (i, None) + else: + # Mismatched parentheses + return (-1, None) + elif char == ';': + # Found something that look like end of statements. If we are currently + # expecting a '<', the matching '>' must have been an operator, since + # template argument list should not contain statements. + while stack and stack[-1] == '>': + stack.pop() + if not stack: + return (-1, None) + + i -= 1 + + return (-1, stack) + + +def ReverseCloseExpression(clean_lines, linenum, pos): + """If input points to ) or } or ] or >, finds the position that opens it. + + If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the + linenum/pos that correspond to the opening of the expression. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + pos: A position on the line. + + Returns: + A tuple (line, linenum, pos) pointer *at* the opening brace, or + (line, 0, -1) if we never find the matching opening brace. Note + we ignore strings and comments when matching; and the line we + return is the 'cleansed' line at linenum. + """ + line = clean_lines.elided[linenum] + if line[pos] not in ')}]>': + return (line, 0, -1) + + # Check last line + (start_pos, stack) = FindStartOfExpressionInLine(line, pos, []) + if start_pos > -1: + return (line, linenum, start_pos) + + # Continue scanning backward + while stack and linenum > 0: + linenum -= 1 + line = clean_lines.elided[linenum] + (start_pos, stack) = FindStartOfExpressionInLine(line, len(line) - 1, stack) + if start_pos > -1: + return (line, linenum, start_pos) + + # Did not find start of expression before beginning of file, give up + return (line, 0, -1) + + +def CheckForCopyright(filename, lines, error): + """Logs an error if no Copyright message appears at the top of the file.""" + + # We'll say it should occur by line 10. Don't forget there's a + # dummy line at the front. + for line in xrange(1, min(len(lines), 11)): + if re.search(r'Copyright', lines[line], re.I): break + else: # means no copyright line was found + error(filename, 0, 'legal/copyright', 5, + 'No copyright message found. ' + 'You should have a line: "Copyright [year] "') + + +def GetIndentLevel(line): + """Return the number of leading spaces in line. + + Args: + line: A string to check. + + Returns: + An integer count of leading spaces, possibly zero. + """ + indent = Match(r'^( *)\S', line) + if indent: + return len(indent.group(1)) + else: + return 0 + +def PathSplitToList(path): + """Returns the path split into a list by the separator. + + Args: + path: An absolute or relative path (e.g. '/a/b/c/' or '../a') + + Returns: + A list of path components (e.g. ['a', 'b', 'c]). + """ + lst = [] + while True: + (head, tail) = os.path.split(path) + if head == path: # absolute paths end + lst.append(head) + break + if tail == path: # relative paths end + lst.append(tail) + break + + path = head + lst.append(tail) + + lst.reverse() + return lst + +def GetHeaderGuardCPPVariable(filename): + """Returns the CPP variable that should be used as a header guard. + + Args: + filename: The name of a C++ header file. + + Returns: + The CPP variable that should be used as a header guard in the + named file. + + """ + + # Restores original filename in case that cpplint is invoked from Emacs's + # flymake. + filename = re.sub(r'_flymake\.h$', '.h', filename) + filename = re.sub(r'/\.flymake/([^/]*)$', r'/\1', filename) + # Replace 'c++' with 'cpp'. + filename = filename.replace('C++', 'cpp').replace('c++', 'cpp') + + fileinfo = FileInfo(filename) + file_path_from_root = fileinfo.RepositoryName() + + def FixupPathFromRoot(): + if _root_debug: + sys.stderr.write("\n_root fixup, _root = '%s', repository name = '%s'\n" + % (_root, fileinfo.RepositoryName())) + + # Process the file path with the --root flag if it was set. + if not _root: + if _root_debug: + sys.stderr.write("_root unspecified\n") + return file_path_from_root + + def StripListPrefix(lst, prefix): + # f(['x', 'y'], ['w, z']) -> None (not a valid prefix) + if lst[:len(prefix)] != prefix: + return None + # f(['a, 'b', 'c', 'd'], ['a', 'b']) -> ['c', 'd'] + return lst[(len(prefix)):] + + # root behavior: + # --root=subdir , lstrips subdir from the header guard + maybe_path = StripListPrefix(PathSplitToList(file_path_from_root), + PathSplitToList(_root)) + + if _root_debug: + sys.stderr.write(("_root lstrip (maybe_path=%s, file_path_from_root=%s," + + " _root=%s)\n") % (maybe_path, file_path_from_root, _root)) + + if maybe_path: + return os.path.join(*maybe_path) + + # --root=.. , will prepend the outer directory to the header guard + full_path = fileinfo.FullName() + root_abspath = os.path.abspath(_root) + + maybe_path = StripListPrefix(PathSplitToList(full_path), + PathSplitToList(root_abspath)) + + if _root_debug: + sys.stderr.write(("_root prepend (maybe_path=%s, full_path=%s, " + + "root_abspath=%s)\n") % (maybe_path, full_path, root_abspath)) + + if maybe_path: + return os.path.join(*maybe_path) + + if _root_debug: + sys.stderr.write("_root ignore, returning %s\n" % (file_path_from_root)) + + # --root=FAKE_DIR is ignored + return file_path_from_root + + file_path_from_root = FixupPathFromRoot() + return re.sub(r'[^a-zA-Z0-9]', '_', file_path_from_root).upper() + '_' + + +def CheckForHeaderGuard(filename, clean_lines, error): + """Checks that the file contains a header guard. + + Logs an error if no #ifndef header guard is present. For other + headers, checks that the full pathname is used. + + Args: + filename: The name of the C++ header file. + clean_lines: A CleansedLines instance containing the file. + error: The function to call with any errors found. + """ + + # Don't check for header guards if there are error suppression + # comments somewhere in this file. + # + # Because this is silencing a warning for a nonexistent line, we + # only support the very specific NOLINT(build/header_guard) syntax, + # and not the general NOLINT or NOLINT(*) syntax. + raw_lines = clean_lines.lines_without_raw_strings + for i in raw_lines: + if Search(r'//\s*NOLINT\(build/header_guard\)', i): + return + + # Allow pragma once instead of header guards + for i in raw_lines: + if Search(r'^\s*#pragma\s+once', i): + return + + cppvar = GetHeaderGuardCPPVariable(filename) + + ifndef = '' + ifndef_linenum = 0 + define = '' + endif = '' + endif_linenum = 0 + for linenum, line in enumerate(raw_lines): + linesplit = line.split() + if len(linesplit) >= 2: + # find the first occurrence of #ifndef and #define, save arg + if not ifndef and linesplit[0] == '#ifndef': + # set ifndef to the header guard presented on the #ifndef line. + ifndef = linesplit[1] + ifndef_linenum = linenum + if not define and linesplit[0] == '#define': + define = linesplit[1] + # find the last occurrence of #endif, save entire line + if line.startswith('#endif'): + endif = line + endif_linenum = linenum + + if not ifndef or not define or ifndef != define: + error(filename, 0, 'build/header_guard', 5, + 'No #ifndef header guard found, suggested CPP variable is: %s' % + cppvar) + return + + # The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__ + # for backward compatibility. + if ifndef != cppvar: + error_level = 0 + if ifndef != cppvar + '_': + error_level = 5 + + ParseNolintSuppressions(filename, raw_lines[ifndef_linenum], ifndef_linenum, + error) + error(filename, ifndef_linenum, 'build/header_guard', error_level, + '#ifndef header guard has wrong style, please use: %s' % cppvar) + + # Check for "//" comments on endif line. + ParseNolintSuppressions(filename, raw_lines[endif_linenum], endif_linenum, + error) + match = Match(r'#endif\s*//\s*' + cppvar + r'(_)?\b', endif) + if match: + if match.group(1) == '_': + # Issue low severity warning for deprecated double trailing underscore + error(filename, endif_linenum, 'build/header_guard', 0, + '#endif line should be "#endif // %s"' % cppvar) + return + + # Didn't find the corresponding "//" comment. If this file does not + # contain any "//" comments at all, it could be that the compiler + # only wants "/**/" comments, look for those instead. + no_single_line_comments = True + for i in xrange(1, len(raw_lines) - 1): + line = raw_lines[i] + if Match(r'^(?:(?:\'(?:\.|[^\'])*\')|(?:"(?:\.|[^"])*")|[^\'"])*//', line): + no_single_line_comments = False + break + + if no_single_line_comments: + match = Match(r'#endif\s*/\*\s*' + cppvar + r'(_)?\s*\*/', endif) + if match: + if match.group(1) == '_': + # Low severity warning for double trailing underscore + error(filename, endif_linenum, 'build/header_guard', 0, + '#endif line should be "#endif /* %s */"' % cppvar) + return + + # Didn't find anything + error(filename, endif_linenum, 'build/header_guard', 5, + '#endif line should be "#endif // %s"' % cppvar) + + +def CheckHeaderFileIncluded(filename, include_state, error): + """Logs an error if a source file does not include its header.""" + + # Do not check test files + fileinfo = FileInfo(filename) + if Search(_TEST_FILE_SUFFIX, fileinfo.BaseName()): + return + + for ext in GetHeaderExtensions(): + basefilename = filename[0:len(filename) - len(fileinfo.Extension())] + headerfile = basefilename + '.' + ext + if not os.path.exists(headerfile): + continue + headername = FileInfo(headerfile).RepositoryName() + first_include = None + include_uses_unix_dir_aliases = False + for section_list in include_state.include_list: + for f in section_list: + include_text = f[0] + if "./" in include_text: + include_uses_unix_dir_aliases = True + if headername in include_text or include_text in headername: + return + if not first_include: + first_include = f[1] + + message = '%s should include its header file %s' % (fileinfo.RepositoryName(), headername) + if include_uses_unix_dir_aliases: + message += ". Relative paths like . and .. are not allowed." + + error(filename, first_include, 'build/include', 5, message) + + +def CheckForBadCharacters(filename, lines, error): + """Logs an error for each line containing bad characters. + + Two kinds of bad characters: + + 1. Unicode replacement characters: These indicate that either the file + contained invalid UTF-8 (likely) or Unicode replacement characters (which + it shouldn't). Note that it's possible for this to throw off line + numbering if the invalid UTF-8 occurred adjacent to a newline. + + 2. NUL bytes. These are problematic for some tools. + + Args: + filename: The name of the current file. + lines: An array of strings, each representing a line of the file. + error: The function to call with any errors found. + """ + for linenum, line in enumerate(lines): + if unicode_escape_decode('\ufffd') in line: + error(filename, linenum, 'readability/utf8', 5, + 'Line contains invalid UTF-8 (or Unicode replacement character).') + if '\0' in line: + error(filename, linenum, 'readability/nul', 5, 'Line contains NUL byte.') + + +def CheckForNewlineAtEOF(filename, lines, error): + """Logs an error if there is no newline char at the end of the file. + + Args: + filename: The name of the current file. + lines: An array of strings, each representing a line of the file. + error: The function to call with any errors found. + """ + + # The array lines() was created by adding two newlines to the + # original file (go figure), then splitting on \n. + # To verify that the file ends in \n, we just have to make sure the + # last-but-two element of lines() exists and is empty. + if len(lines) < 3 or lines[-2]: + error(filename, len(lines) - 2, 'whitespace/ending_newline', 5, + 'Could not find a newline character at the end of the file.') + + +def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error): + """Logs an error if we see /* ... */ or "..." that extend past one line. + + /* ... */ comments are legit inside macros, for one line. + Otherwise, we prefer // comments, so it's ok to warn about the + other. Likewise, it's ok for strings to extend across multiple + lines, as long as a line continuation character (backslash) + terminates each line. Although not currently prohibited by the C++ + style guide, it's ugly and unnecessary. We don't do well with either + in this lint program, so we warn about both. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Remove all \\ (escaped backslashes) from the line. They are OK, and the + # second (escaped) slash may trigger later \" detection erroneously. + line = line.replace('\\\\', '') + + if line.count('/*') > line.count('*/'): + error(filename, linenum, 'readability/multiline_comment', 5, + 'Complex multi-line /*...*/-style comment found. ' + 'Lint may give bogus warnings. ' + 'Consider replacing these with //-style comments, ' + 'with #if 0...#endif, ' + 'or with more clearly structured multi-line comments.') + + if (line.count('"') - line.count('\\"')) % 2: + error(filename, linenum, 'readability/multiline_string', 5, + 'Multi-line string ("...") found. This lint script doesn\'t ' + 'do well with such strings, and may give bogus warnings. ' + 'Use C++11 raw strings or concatenation instead.') + + +# (non-threadsafe name, thread-safe alternative, validation pattern) +# +# The validation pattern is used to eliminate false positives such as: +# _rand(); // false positive due to substring match. +# ->rand(); // some member function rand(). +# ACMRandom rand(seed); // some variable named rand. +# ISAACRandom rand(); // another variable named rand. +# +# Basically we require the return value of these functions to be used +# in some expression context on the same line by matching on some +# operator before the function name. This eliminates constructors and +# member function calls. +_UNSAFE_FUNC_PREFIX = r'(?:[-+*/=%^&|(<]\s*|>\s+)' +_THREADING_LIST = ( + ('asctime(', 'asctime_r(', _UNSAFE_FUNC_PREFIX + r'asctime\([^)]+\)'), + ('ctime(', 'ctime_r(', _UNSAFE_FUNC_PREFIX + r'ctime\([^)]+\)'), + ('getgrgid(', 'getgrgid_r(', _UNSAFE_FUNC_PREFIX + r'getgrgid\([^)]+\)'), + ('getgrnam(', 'getgrnam_r(', _UNSAFE_FUNC_PREFIX + r'getgrnam\([^)]+\)'), + ('getlogin(', 'getlogin_r(', _UNSAFE_FUNC_PREFIX + r'getlogin\(\)'), + ('getpwnam(', 'getpwnam_r(', _UNSAFE_FUNC_PREFIX + r'getpwnam\([^)]+\)'), + ('getpwuid(', 'getpwuid_r(', _UNSAFE_FUNC_PREFIX + r'getpwuid\([^)]+\)'), + ('gmtime(', 'gmtime_r(', _UNSAFE_FUNC_PREFIX + r'gmtime\([^)]+\)'), + ('localtime(', 'localtime_r(', _UNSAFE_FUNC_PREFIX + r'localtime\([^)]+\)'), + ('rand(', 'rand_r(', _UNSAFE_FUNC_PREFIX + r'rand\(\)'), + ('strtok(', 'strtok_r(', + _UNSAFE_FUNC_PREFIX + r'strtok\([^)]+\)'), + ('ttyname(', 'ttyname_r(', _UNSAFE_FUNC_PREFIX + r'ttyname\([^)]+\)'), + ) + + +def CheckPosixThreading(filename, clean_lines, linenum, error): + """Checks for calls to thread-unsafe functions. + + Much code has been originally written without consideration of + multi-threading. Also, engineers are relying on their old experience; + they have learned posix before threading extensions were added. These + tests guide the engineers to use thread-safe functions (when using + posix directly). + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + for single_thread_func, multithread_safe_func, pattern in _THREADING_LIST: + # Additional pattern matching check to confirm that this is the + # function we are looking for + if Search(pattern, line): + error(filename, linenum, 'runtime/threadsafe_fn', 2, + 'Consider using ' + multithread_safe_func + + '...) instead of ' + single_thread_func + + '...) for improved thread safety.') + + +def CheckVlogArguments(filename, clean_lines, linenum, error): + """Checks that VLOG() is only used for defining a logging level. + + For example, VLOG(2) is correct. VLOG(INFO), VLOG(WARNING), VLOG(ERROR), and + VLOG(FATAL) are not. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + if Search(r'\bVLOG\((INFO|ERROR|WARNING|DFATAL|FATAL)\)', line): + error(filename, linenum, 'runtime/vlog', 5, + 'VLOG() should be used with numeric verbosity level. ' + 'Use LOG() if you want symbolic severity levels.') + +# Matches invalid increment: *count++, which moves pointer instead of +# incrementing a value. +_RE_PATTERN_INVALID_INCREMENT = re.compile( + r'^\s*\*\w+(\+\+|--);') + + +def CheckInvalidIncrement(filename, clean_lines, linenum, error): + """Checks for invalid increment *count++. + + For example following function: + void increment_counter(int* count) { + *count++; + } + is invalid, because it effectively does count++, moving pointer, and should + be replaced with ++*count, (*count)++ or *count += 1. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + if _RE_PATTERN_INVALID_INCREMENT.match(line): + error(filename, linenum, 'runtime/invalid_increment', 5, + 'Changing pointer instead of value (or unused value of operator*).') + + +def IsMacroDefinition(clean_lines, linenum): + if Search(r'^#define', clean_lines[linenum]): + return True + + if linenum > 0 and Search(r'\\$', clean_lines[linenum - 1]): + return True + + return False + + +def IsForwardClassDeclaration(clean_lines, linenum): + return Match(r'^\s*(\btemplate\b)*.*class\s+\w+;\s*$', clean_lines[linenum]) + + +class _BlockInfo(object): + """Stores information about a generic block of code.""" + + def __init__(self, linenum, seen_open_brace): + self.starting_linenum = linenum + self.seen_open_brace = seen_open_brace + self.open_parentheses = 0 + self.inline_asm = _NO_ASM + self.check_namespace_indentation = False + + def CheckBegin(self, filename, clean_lines, linenum, error): + """Run checks that applies to text up to the opening brace. + + This is mostly for checking the text after the class identifier + and the "{", usually where the base class is specified. For other + blocks, there isn't much to check, so we always pass. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + pass + + def CheckEnd(self, filename, clean_lines, linenum, error): + """Run checks that applies to text after the closing brace. + + This is mostly used for checking end of namespace comments. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + pass + + def IsBlockInfo(self): + """Returns true if this block is a _BlockInfo. + + This is convenient for verifying that an object is an instance of + a _BlockInfo, but not an instance of any of the derived classes. + + Returns: + True for this class, False for derived classes. + """ + return self.__class__ == _BlockInfo + + +class _ExternCInfo(_BlockInfo): + """Stores information about an 'extern "C"' block.""" + + def __init__(self, linenum): + _BlockInfo.__init__(self, linenum, True) + + +class _ClassInfo(_BlockInfo): + """Stores information about a class.""" + + def __init__(self, name, class_or_struct, clean_lines, linenum): + _BlockInfo.__init__(self, linenum, False) + self.name = name + self.is_derived = False + self.check_namespace_indentation = True + if class_or_struct == 'struct': + self.access = 'public' + self.is_struct = True + else: + self.access = 'private' + self.is_struct = False + + # Remember initial indentation level for this class. Using raw_lines here + # instead of elided to account for leading comments. + self.class_indent = GetIndentLevel(clean_lines.raw_lines[linenum]) + + # Try to find the end of the class. This will be confused by things like: + # class A { + # } *x = { ... + # + # But it's still good enough for CheckSectionSpacing. + self.last_line = 0 + depth = 0 + for i in range(linenum, clean_lines.NumLines()): + line = clean_lines.elided[i] + depth += line.count('{') - line.count('}') + if not depth: + self.last_line = i + break + + def CheckBegin(self, filename, clean_lines, linenum, error): + # Look for a bare ':' + if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]): + self.is_derived = True + + def CheckEnd(self, filename, clean_lines, linenum, error): + # If there is a DISALLOW macro, it should appear near the end of + # the class. + seen_last_thing_in_class = False + for i in xrange(linenum - 1, self.starting_linenum, -1): + match = Search( + r'\b(DISALLOW_COPY_AND_ASSIGN|DISALLOW_IMPLICIT_CONSTRUCTORS)\(' + + self.name + r'\)', + clean_lines.elided[i]) + if match: + if seen_last_thing_in_class: + error(filename, i, 'readability/constructors', 3, + match.group(1) + ' should be the last thing in the class') + break + + if not Match(r'^\s*$', clean_lines.elided[i]): + seen_last_thing_in_class = True + + # Check that closing brace is aligned with beginning of the class. + # Only do this if the closing brace is indented by only whitespaces. + # This means we will not check single-line class definitions. + indent = Match(r'^( *)\}', clean_lines.elided[linenum]) + if indent and len(indent.group(1)) != self.class_indent: + if self.is_struct: + parent = 'struct ' + self.name + else: + parent = 'class ' + self.name + error(filename, linenum, 'whitespace/indent', 3, + 'Closing brace should be aligned with beginning of %s' % parent) + + +class _NamespaceInfo(_BlockInfo): + """Stores information about a namespace.""" + + def __init__(self, name, linenum): + _BlockInfo.__init__(self, linenum, False) + self.name = name or '' + self.check_namespace_indentation = True + + def CheckEnd(self, filename, clean_lines, linenum, error): + """Check end of namespace comments.""" + line = clean_lines.raw_lines[linenum] + + # Check how many lines is enclosed in this namespace. Don't issue + # warning for missing namespace comments if there aren't enough + # lines. However, do apply checks if there is already an end of + # namespace comment and it's incorrect. + # + # TODO(unknown): We always want to check end of namespace comments + # if a namespace is large, but sometimes we also want to apply the + # check if a short namespace contained nontrivial things (something + # other than forward declarations). There is currently no logic on + # deciding what these nontrivial things are, so this check is + # triggered by namespace size only, which works most of the time. + if (linenum - self.starting_linenum < 10 + and not Match(r'^\s*};*\s*(//|/\*).*\bnamespace\b', line)): + return + + # Look for matching comment at end of namespace. + # + # Note that we accept C style "/* */" comments for terminating + # namespaces, so that code that terminate namespaces inside + # preprocessor macros can be cpplint clean. + # + # We also accept stuff like "// end of namespace ." with the + # period at the end. + # + # Besides these, we don't accept anything else, otherwise we might + # get false negatives when existing comment is a substring of the + # expected namespace. + if self.name: + # Named namespace + if not Match((r'^\s*};*\s*(//|/\*).*\bnamespace\s+' + + re.escape(self.name) + r'[\*/\.\\\s]*$'), + line): + error(filename, linenum, 'readability/namespace', 5, + 'Namespace should be terminated with "// namespace %s"' % + self.name) + else: + # Anonymous namespace + if not Match(r'^\s*};*\s*(//|/\*).*\bnamespace[\*/\.\\\s]*$', line): + # If "// namespace anonymous" or "// anonymous namespace (more text)", + # mention "// anonymous namespace" as an acceptable form + if Match(r'^\s*}.*\b(namespace anonymous|anonymous namespace)\b', line): + error(filename, linenum, 'readability/namespace', 5, + 'Anonymous namespace should be terminated with "// namespace"' + ' or "// anonymous namespace"') + else: + error(filename, linenum, 'readability/namespace', 5, + 'Anonymous namespace should be terminated with "// namespace"') + + +class _PreprocessorInfo(object): + """Stores checkpoints of nesting stacks when #if/#else is seen.""" + + def __init__(self, stack_before_if): + # The entire nesting stack before #if + self.stack_before_if = stack_before_if + + # The entire nesting stack up to #else + self.stack_before_else = [] + + # Whether we have already seen #else or #elif + self.seen_else = False + + +class NestingState(object): + """Holds states related to parsing braces.""" + + def __init__(self): + # Stack for tracking all braces. An object is pushed whenever we + # see a "{", and popped when we see a "}". Only 3 types of + # objects are possible: + # - _ClassInfo: a class or struct. + # - _NamespaceInfo: a namespace. + # - _BlockInfo: some other type of block. + self.stack = [] + + # Top of the previous stack before each Update(). + # + # Because the nesting_stack is updated at the end of each line, we + # had to do some convoluted checks to find out what is the current + # scope at the beginning of the line. This check is simplified by + # saving the previous top of nesting stack. + # + # We could save the full stack, but we only need the top. Copying + # the full nesting stack would slow down cpplint by ~10%. + self.previous_stack_top = [] + + # Stack of _PreprocessorInfo objects. + self.pp_stack = [] + + def SeenOpenBrace(self): + """Check if we have seen the opening brace for the innermost block. + + Returns: + True if we have seen the opening brace, False if the innermost + block is still expecting an opening brace. + """ + return (not self.stack) or self.stack[-1].seen_open_brace + + def InNamespaceBody(self): + """Check if we are currently one level inside a namespace body. + + Returns: + True if top of the stack is a namespace block, False otherwise. + """ + return self.stack and isinstance(self.stack[-1], _NamespaceInfo) + + def InExternC(self): + """Check if we are currently one level inside an 'extern "C"' block. + + Returns: + True if top of the stack is an extern block, False otherwise. + """ + return self.stack and isinstance(self.stack[-1], _ExternCInfo) + + def InClassDeclaration(self): + """Check if we are currently one level inside a class or struct declaration. + + Returns: + True if top of the stack is a class/struct, False otherwise. + """ + return self.stack and isinstance(self.stack[-1], _ClassInfo) + + def InAsmBlock(self): + """Check if we are currently one level inside an inline ASM block. + + Returns: + True if the top of the stack is a block containing inline ASM. + """ + return self.stack and self.stack[-1].inline_asm != _NO_ASM + + def InTemplateArgumentList(self, clean_lines, linenum, pos): + """Check if current position is inside template argument list. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + pos: position just after the suspected template argument. + Returns: + True if (linenum, pos) is inside template arguments. + """ + while linenum < clean_lines.NumLines(): + # Find the earliest character that might indicate a template argument + line = clean_lines.elided[linenum] + match = Match(r'^[^{};=\[\]\.<>]*(.)', line[pos:]) + if not match: + linenum += 1 + pos = 0 + continue + token = match.group(1) + pos += len(match.group(0)) + + # These things do not look like template argument list: + # class Suspect { + # class Suspect x; } + if token in ('{', '}', ';'): return False + + # These things look like template argument list: + # template + # template + # template + # template + if token in ('>', '=', '[', ']', '.'): return True + + # Check if token is an unmatched '<'. + # If not, move on to the next character. + if token != '<': + pos += 1 + if pos >= len(line): + linenum += 1 + pos = 0 + continue + + # We can't be sure if we just find a single '<', and need to + # find the matching '>'. + (_, end_line, end_pos) = CloseExpression(clean_lines, linenum, pos - 1) + if end_pos < 0: + # Not sure if template argument list or syntax error in file + return False + linenum = end_line + pos = end_pos + return False + + def UpdatePreprocessor(self, line): + """Update preprocessor stack. + + We need to handle preprocessors due to classes like this: + #ifdef SWIG + struct ResultDetailsPageElementExtensionPoint { + #else + struct ResultDetailsPageElementExtensionPoint : public Extension { + #endif + + We make the following assumptions (good enough for most files): + - Preprocessor condition evaluates to true from #if up to first + #else/#elif/#endif. + + - Preprocessor condition evaluates to false from #else/#elif up + to #endif. We still perform lint checks on these lines, but + these do not affect nesting stack. + + Args: + line: current line to check. + """ + if Match(r'^\s*#\s*(if|ifdef|ifndef)\b', line): + # Beginning of #if block, save the nesting stack here. The saved + # stack will allow us to restore the parsing state in the #else case. + self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack))) + elif Match(r'^\s*#\s*(else|elif)\b', line): + # Beginning of #else block + if self.pp_stack: + if not self.pp_stack[-1].seen_else: + # This is the first #else or #elif block. Remember the + # whole nesting stack up to this point. This is what we + # keep after the #endif. + self.pp_stack[-1].seen_else = True + self.pp_stack[-1].stack_before_else = copy.deepcopy(self.stack) + + # Restore the stack to how it was before the #if + self.stack = copy.deepcopy(self.pp_stack[-1].stack_before_if) + else: + # TODO(unknown): unexpected #else, issue warning? + pass + elif Match(r'^\s*#\s*endif\b', line): + # End of #if or #else blocks. + if self.pp_stack: + # If we saw an #else, we will need to restore the nesting + # stack to its former state before the #else, otherwise we + # will just continue from where we left off. + if self.pp_stack[-1].seen_else: + # Here we can just use a shallow copy since we are the last + # reference to it. + self.stack = self.pp_stack[-1].stack_before_else + # Drop the corresponding #if + self.pp_stack.pop() + else: + # TODO(unknown): unexpected #endif, issue warning? + pass + + # TODO(unknown): Update() is too long, but we will refactor later. + def Update(self, filename, clean_lines, linenum, error): + """Update nesting state with current line. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Remember top of the previous nesting stack. + # + # The stack is always pushed/popped and not modified in place, so + # we can just do a shallow copy instead of copy.deepcopy. Using + # deepcopy would slow down cpplint by ~28%. + if self.stack: + self.previous_stack_top = self.stack[-1] + else: + self.previous_stack_top = None + + # Update pp_stack + self.UpdatePreprocessor(line) + + # Count parentheses. This is to avoid adding struct arguments to + # the nesting stack. + if self.stack: + inner_block = self.stack[-1] + depth_change = line.count('(') - line.count(')') + inner_block.open_parentheses += depth_change + + # Also check if we are starting or ending an inline assembly block. + if inner_block.inline_asm in (_NO_ASM, _END_ASM): + if (depth_change != 0 and + inner_block.open_parentheses == 1 and + _MATCH_ASM.match(line)): + # Enter assembly block + inner_block.inline_asm = _INSIDE_ASM + else: + # Not entering assembly block. If previous line was _END_ASM, + # we will now shift to _NO_ASM state. + inner_block.inline_asm = _NO_ASM + elif (inner_block.inline_asm == _INSIDE_ASM and + inner_block.open_parentheses == 0): + # Exit assembly block + inner_block.inline_asm = _END_ASM + + # Consume namespace declaration at the beginning of the line. Do + # this in a loop so that we catch same line declarations like this: + # namespace proto2 { namespace bridge { class MessageSet; } } + while True: + # Match start of namespace. The "\b\s*" below catches namespace + # declarations even if it weren't followed by a whitespace, this + # is so that we don't confuse our namespace checker. The + # missing spaces will be flagged by CheckSpacing. + namespace_decl_match = Match(r'^\s*namespace\b\s*([:\w]+)?(.*)$', line) + if not namespace_decl_match: + break + + new_namespace = _NamespaceInfo(namespace_decl_match.group(1), linenum) + self.stack.append(new_namespace) + + line = namespace_decl_match.group(2) + if line.find('{') != -1: + new_namespace.seen_open_brace = True + line = line[line.find('{') + 1:] + + # Look for a class declaration in whatever is left of the line + # after parsing namespaces. The regexp accounts for decorated classes + # such as in: + # class LOCKABLE API Object { + # }; + class_decl_match = Match( + r'^(\s*(?:template\s*<[\w\s<>,:=]*>\s*)?' + r'(class|struct)\s+(?:[a-zA-Z0-9_]+\s+)*(\w+(?:::\w+)*))' + r'(.*)$', line) + if (class_decl_match and + (not self.stack or self.stack[-1].open_parentheses == 0)): + # We do not want to accept classes that are actually template arguments: + # template , + # template class Ignore3> + # void Function() {}; + # + # To avoid template argument cases, we scan forward and look for + # an unmatched '>'. If we see one, assume we are inside a + # template argument list. + end_declaration = len(class_decl_match.group(1)) + if not self.InTemplateArgumentList(clean_lines, linenum, end_declaration): + self.stack.append(_ClassInfo( + class_decl_match.group(3), class_decl_match.group(2), + clean_lines, linenum)) + line = class_decl_match.group(4) + + # If we have not yet seen the opening brace for the innermost block, + # run checks here. + if not self.SeenOpenBrace(): + self.stack[-1].CheckBegin(filename, clean_lines, linenum, error) + + # Update access control if we are inside a class/struct + if self.stack and isinstance(self.stack[-1], _ClassInfo): + classinfo = self.stack[-1] + access_match = Match( + r'^(.*)\b(public|private|protected|signals)(\s+(?:slots\s*)?)?' + r':(?:[^:]|$)', + line) + if access_match: + classinfo.access = access_match.group(2) + + # Check that access keywords are indented +1 space. Skip this + # check if the keywords are not preceded by whitespaces. + indent = access_match.group(1) + if (len(indent) != classinfo.class_indent + 1 and + Match(r'^\s*$', indent)): + if classinfo.is_struct: + parent = 'struct ' + classinfo.name + else: + parent = 'class ' + classinfo.name + slots = '' + if access_match.group(3): + slots = access_match.group(3) + error(filename, linenum, 'whitespace/indent', 3, + '%s%s: should be indented +1 space inside %s' % ( + access_match.group(2), slots, parent)) + + # Consume braces or semicolons from what's left of the line + while True: + # Match first brace, semicolon, or closed parenthesis. + matched = Match(r'^[^{;)}]*([{;)}])(.*)$', line) + if not matched: + break + + token = matched.group(1) + if token == '{': + # If namespace or class hasn't seen a opening brace yet, mark + # namespace/class head as complete. Push a new block onto the + # stack otherwise. + if not self.SeenOpenBrace(): + self.stack[-1].seen_open_brace = True + elif Match(r'^extern\s*"[^"]*"\s*\{', line): + self.stack.append(_ExternCInfo(linenum)) + else: + self.stack.append(_BlockInfo(linenum, True)) + if _MATCH_ASM.match(line): + self.stack[-1].inline_asm = _BLOCK_ASM + + elif token == ';' or token == ')': + # If we haven't seen an opening brace yet, but we already saw + # a semicolon, this is probably a forward declaration. Pop + # the stack for these. + # + # Similarly, if we haven't seen an opening brace yet, but we + # already saw a closing parenthesis, then these are probably + # function arguments with extra "class" or "struct" keywords. + # Also pop these stack for these. + if not self.SeenOpenBrace(): + self.stack.pop() + else: # token == '}' + # Perform end of block checks and pop the stack. + if self.stack: + self.stack[-1].CheckEnd(filename, clean_lines, linenum, error) + self.stack.pop() + line = matched.group(2) + + def InnermostClass(self): + """Get class info on the top of the stack. + + Returns: + A _ClassInfo object if we are inside a class, or None otherwise. + """ + for i in range(len(self.stack), 0, -1): + classinfo = self.stack[i - 1] + if isinstance(classinfo, _ClassInfo): + return classinfo + return None + + def CheckCompletedBlocks(self, filename, error): + """Checks that all classes and namespaces have been completely parsed. + + Call this when all lines in a file have been processed. + Args: + filename: The name of the current file. + error: The function to call with any errors found. + """ + # Note: This test can result in false positives if #ifdef constructs + # get in the way of brace matching. See the testBuildClass test in + # cpplint_unittest.py for an example of this. + for obj in self.stack: + if isinstance(obj, _ClassInfo): + error(filename, obj.starting_linenum, 'build/class', 5, + 'Failed to find complete declaration of class %s' % + obj.name) + elif isinstance(obj, _NamespaceInfo): + error(filename, obj.starting_linenum, 'build/namespaces', 5, + 'Failed to find complete declaration of namespace %s' % + obj.name) + + +def CheckForNonStandardConstructs(filename, clean_lines, linenum, + nesting_state, error): + r"""Logs an error if we see certain non-ANSI constructs ignored by gcc-2. + + Complain about several constructs which gcc-2 accepts, but which are + not standard C++. Warning about these in lint is one way to ease the + transition to new compilers. + - put storage class first (e.g. "static const" instead of "const static"). + - "%lld" instead of %qd" in printf-type functions. + - "%1$d" is non-standard in printf-type functions. + - "\%" is an undefined character escape sequence. + - text after #endif is not allowed. + - invalid inner-style forward declaration. + - >? and ?= and )\?=?\s*(\w+|[+-]?\d+)(\.\d*)?', + line): + error(filename, linenum, 'build/deprecated', 3, + '>? and ))?' + # r'\s*const\s*' + type_name + '\s*&\s*\w+\s*;' + error(filename, linenum, 'runtime/member_string_references', 2, + 'const string& members are dangerous. It is much better to use ' + 'alternatives, such as pointers or simple constants.') + + # Everything else in this function operates on class declarations. + # Return early if the top of the nesting stack is not a class, or if + # the class head is not completed yet. + classinfo = nesting_state.InnermostClass() + if not classinfo or not classinfo.seen_open_brace: + return + + # The class may have been declared with namespace or classname qualifiers. + # The constructor and destructor will not have those qualifiers. + base_classname = classinfo.name.split('::')[-1] + + # Look for single-argument constructors that aren't marked explicit. + # Technically a valid construct, but against style. + explicit_constructor_match = Match( + r'\s+(?:(?:inline|constexpr)\s+)*(explicit\s+)?' + r'(?:(?:inline|constexpr)\s+)*%s\s*' + r'\(((?:[^()]|\([^()]*\))*)\)' + % re.escape(base_classname), + line) + + if explicit_constructor_match: + is_marked_explicit = explicit_constructor_match.group(1) + + if not explicit_constructor_match.group(2): + constructor_args = [] + else: + constructor_args = explicit_constructor_match.group(2).split(',') + + # collapse arguments so that commas in template parameter lists and function + # argument parameter lists don't split arguments in two + i = 0 + while i < len(constructor_args): + constructor_arg = constructor_args[i] + while (constructor_arg.count('<') > constructor_arg.count('>') or + constructor_arg.count('(') > constructor_arg.count(')')): + constructor_arg += ',' + constructor_args[i + 1] + del constructor_args[i + 1] + constructor_args[i] = constructor_arg + i += 1 + + variadic_args = [arg for arg in constructor_args if '&&...' in arg] + defaulted_args = [arg for arg in constructor_args if '=' in arg] + noarg_constructor = (not constructor_args or # empty arg list + # 'void' arg specifier + (len(constructor_args) == 1 and + constructor_args[0].strip() == 'void')) + onearg_constructor = ((len(constructor_args) == 1 and # exactly one arg + not noarg_constructor) or + # all but at most one arg defaulted + (len(constructor_args) >= 1 and + not noarg_constructor and + len(defaulted_args) >= len(constructor_args) - 1) or + # variadic arguments with zero or one argument + (len(constructor_args) <= 2 and + len(variadic_args) >= 1)) + initializer_list_constructor = bool( + onearg_constructor and + Search(r'\bstd\s*::\s*initializer_list\b', constructor_args[0])) + copy_constructor = bool( + onearg_constructor and + Match(r'((const\s+(volatile\s+)?)?|(volatile\s+(const\s+)?))?' + r'%s(\s*<[^>]*>)?(\s+const)?\s*(?:<\w+>\s*)?&' + % re.escape(base_classname), constructor_args[0].strip())) + + if (not is_marked_explicit and + onearg_constructor and + not initializer_list_constructor and + not copy_constructor): + if defaulted_args or variadic_args: + error(filename, linenum, 'runtime/explicit', 5, + 'Constructors callable with one argument ' + 'should be marked explicit.') + else: + error(filename, linenum, 'runtime/explicit', 5, + 'Single-parameter constructors should be marked explicit.') + elif is_marked_explicit and not onearg_constructor: + if noarg_constructor: + error(filename, linenum, 'runtime/explicit', 5, + 'Zero-parameter constructors should not be marked explicit.') + + +def CheckSpacingForFunctionCall(filename, clean_lines, linenum, error): + """Checks for the correctness of various spacing around function calls. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Since function calls often occur inside if/for/while/switch + # expressions - which have their own, more liberal conventions - we + # first see if we should be looking inside such an expression for a + # function call, to which we can apply more strict standards. + fncall = line # if there's no control flow construct, look at whole line + for pattern in (r'\bif\s*\((.*)\)\s*{', + r'\bfor\s*\((.*)\)\s*{', + r'\bwhile\s*\((.*)\)\s*[{;]', + r'\bswitch\s*\((.*)\)\s*{'): + match = Search(pattern, line) + if match: + fncall = match.group(1) # look inside the parens for function calls + break + + # Except in if/for/while/switch, there should never be space + # immediately inside parens (eg "f( 3, 4 )"). We make an exception + # for nested parens ( (a+b) + c ). Likewise, there should never be + # a space before a ( when it's a function argument. I assume it's a + # function argument when the char before the whitespace is legal in + # a function name (alnum + _) and we're not starting a macro. Also ignore + # pointers and references to arrays and functions coz they're too tricky: + # we use a very simple way to recognize these: + # " (something)(maybe-something)" or + # " (something)(maybe-something," or + # " (something)[something]" + # Note that we assume the contents of [] to be short enough that + # they'll never need to wrap. + if ( # Ignore control structures. + not Search(r'\b(if|for|while|switch|return|new|delete|catch|sizeof)\b', + fncall) and + # Ignore pointers/references to functions. + not Search(r' \([^)]+\)\([^)]*(\)|,$)', fncall) and + # Ignore pointers/references to arrays. + not Search(r' \([^)]+\)\[[^\]]+\]', fncall)): + if Search(r'\w\s*\(\s(?!\s*\\$)', fncall): # a ( used for a fn call + error(filename, linenum, 'whitespace/parens', 4, + 'Extra space after ( in function call') + elif Search(r'\(\s+(?!(\s*\\)|\()', fncall): + error(filename, linenum, 'whitespace/parens', 2, + 'Extra space after (') + if (Search(r'\w\s+\(', fncall) and + not Search(r'_{0,2}asm_{0,2}\s+_{0,2}volatile_{0,2}\s+\(', fncall) and + not Search(r'#\s*define|typedef|using\s+\w+\s*=', fncall) and + not Search(r'\w\s+\((\w+::)*\*\w+\)\(', fncall) and + not Search(r'\bcase\s+\(', fncall)): + # TODO(unknown): Space after an operator function seem to be a common + # error, silence those for now by restricting them to highest verbosity. + if Search(r'\boperator_*\b', line): + error(filename, linenum, 'whitespace/parens', 0, + 'Extra space before ( in function call') + else: + error(filename, linenum, 'whitespace/parens', 4, + 'Extra space before ( in function call') + # If the ) is followed only by a newline or a { + newline, assume it's + # part of a control statement (if/while/etc), and don't complain + if Search(r'[^)]\s+\)\s*[^{\s]', fncall): + # If the closing parenthesis is preceded by only whitespaces, + # try to give a more descriptive error message. + if Search(r'^\s+\)', fncall): + error(filename, linenum, 'whitespace/parens', 2, + 'Closing ) should be moved to the previous line') + else: + error(filename, linenum, 'whitespace/parens', 2, + 'Extra space before )') + + +def IsBlankLine(line): + """Returns true if the given line is blank. + + We consider a line to be blank if the line is empty or consists of + only white spaces. + + Args: + line: A line of a string. + + Returns: + True, if the given line is blank. + """ + return not line or line.isspace() + + +def CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line, + error): + is_namespace_indent_item = ( + len(nesting_state.stack) > 1 and + nesting_state.stack[-1].check_namespace_indentation and + isinstance(nesting_state.previous_stack_top, _NamespaceInfo) and + nesting_state.previous_stack_top == nesting_state.stack[-2]) + + if ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item, + clean_lines.elided, line): + CheckItemIndentationInNamespace(filename, clean_lines.elided, + line, error) + + +def CheckForFunctionLengths(filename, clean_lines, linenum, + function_state, error): + """Reports for long function bodies. + + For an overview why this is done, see: + https://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions + + Uses a simplistic algorithm assuming other style guidelines + (especially spacing) are followed. + Only checks unindented functions, so class members are unchecked. + Trivial bodies are unchecked, so constructors with huge initializer lists + may be missed. + Blank/comment lines are not counted so as to avoid encouraging the removal + of vertical space and comments just to get through a lint check. + NOLINT *on the last line of a function* disables this check. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + function_state: Current function name and lines in body so far. + error: The function to call with any errors found. + """ + lines = clean_lines.lines + line = lines[linenum] + joined_line = '' + + starting_func = False + regexp = r'(\w(\w|::|\*|\&|\s)*)\(' # decls * & space::name( ... + match_result = Match(regexp, line) + if match_result: + # If the name is all caps and underscores, figure it's a macro and + # ignore it, unless it's TEST or TEST_F. + function_name = match_result.group(1).split()[-1] + if function_name == 'TEST' or function_name == 'TEST_F' or ( + not Match(r'[A-Z_]+$', function_name)): + starting_func = True + + if starting_func: + body_found = False + for start_linenum in xrange(linenum, clean_lines.NumLines()): + start_line = lines[start_linenum] + joined_line += ' ' + start_line.lstrip() + if Search(r'(;|})', start_line): # Declarations and trivial functions + body_found = True + break # ... ignore + if Search(r'{', start_line): + body_found = True + function = Search(r'((\w|:)*)\(', line).group(1) + if Match(r'TEST', function): # Handle TEST... macros + parameter_regexp = Search(r'(\(.*\))', joined_line) + if parameter_regexp: # Ignore bad syntax + function += parameter_regexp.group(1) + else: + function += '()' + function_state.Begin(function) + break + if not body_found: + # No body for the function (or evidence of a non-function) was found. + error(filename, linenum, 'readability/fn_size', 5, + 'Lint failed to find start of function body.') + elif Match(r'^\}\s*$', line): # function end + function_state.Check(error, filename, linenum) + function_state.End() + elif not Match(r'^\s*$', line): + function_state.Count() # Count non-blank/non-comment lines. + + +_RE_PATTERN_TODO = re.compile(r'^//(\s*)TODO(\(.+?\))?:?(\s|$)?') + + +def CheckComment(line, filename, linenum, next_line_start, error): + """Checks for common mistakes in comments. + + Args: + line: The line in question. + filename: The name of the current file. + linenum: The number of the line to check. + next_line_start: The first non-whitespace column of the next line. + error: The function to call with any errors found. + """ + commentpos = line.find('//') + if commentpos != -1: + # Check if the // may be in quotes. If so, ignore it + if re.sub(r'\\.', '', line[0:commentpos]).count('"') % 2 == 0: + # Allow one space for new scopes, two spaces otherwise: + if (not (Match(r'^.*{ *//', line) and next_line_start == commentpos) and + ((commentpos >= 1 and + line[commentpos-1] not in string.whitespace) or + (commentpos >= 2 and + line[commentpos-2] not in string.whitespace))): + error(filename, linenum, 'whitespace/comments', 2, + 'At least two spaces is best between code and comments') + + # Checks for common mistakes in TODO comments. + comment = line[commentpos:] + match = _RE_PATTERN_TODO.match(comment) + if match: + # One whitespace is correct; zero whitespace is handled elsewhere. + leading_whitespace = match.group(1) + if len(leading_whitespace) > 1: + error(filename, linenum, 'whitespace/todo', 2, + 'Too many spaces before TODO') + + username = match.group(2) + if not username: + error(filename, linenum, 'readability/todo', 2, + 'Missing username in TODO; it should look like ' + '"// TODO(my_username): Stuff."') + + middle_whitespace = match.group(3) + # Comparisons made explicit for correctness -- pylint: disable=g-explicit-bool-comparison + if middle_whitespace != ' ' and middle_whitespace != '': + error(filename, linenum, 'whitespace/todo', 2, + 'TODO(my_username) should be followed by a space') + + # If the comment contains an alphanumeric character, there + # should be a space somewhere between it and the // unless + # it's a /// or //! Doxygen comment. + if (Match(r'//[^ ]*\w', comment) and + not Match(r'(///|//\!)(\s+|$)', comment)): + error(filename, linenum, 'whitespace/comments', 4, + 'Should have a space between // and comment') + + +def CheckSpacing(filename, clean_lines, linenum, nesting_state, error): + """Checks for the correctness of various spacing issues in the code. + + Things we check for: spaces around operators, spaces after + if/for/while/switch, no spaces around parens in function calls, two + spaces between code and comment, don't start a block with a blank + line, don't end a function with a blank line, don't add a blank line + after public/protected/private, don't have too many blank lines in a row. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + + # Don't use "elided" lines here, otherwise we can't check commented lines. + # Don't want to use "raw" either, because we don't want to check inside C++11 + # raw strings, + raw = clean_lines.lines_without_raw_strings + line = raw[linenum] + + # Before nixing comments, check if the line is blank for no good + # reason. This includes the first line after a block is opened, and + # blank lines at the end of a function (ie, right before a line like '}' + # + # Skip all the blank line checks if we are immediately inside a + # namespace body. In other words, don't issue blank line warnings + # for this block: + # namespace { + # + # } + # + # A warning about missing end of namespace comments will be issued instead. + # + # Also skip blank line checks for 'extern "C"' blocks, which are formatted + # like namespaces. + if (IsBlankLine(line) and + not nesting_state.InNamespaceBody() and + not nesting_state.InExternC()): + elided = clean_lines.elided + prev_line = elided[linenum - 1] + prevbrace = prev_line.rfind('{') + # TODO(unknown): Don't complain if line before blank line, and line after, + # both start with alnums and are indented the same amount. + # This ignores whitespace at the start of a namespace block + # because those are not usually indented. + if prevbrace != -1 and prev_line[prevbrace:].find('}') == -1: + # OK, we have a blank line at the start of a code block. Before we + # complain, we check if it is an exception to the rule: The previous + # non-empty line has the parameters of a function header that are indented + # 4 spaces (because they did not fit in a 80 column line when placed on + # the same line as the function name). We also check for the case where + # the previous line is indented 6 spaces, which may happen when the + # initializers of a constructor do not fit into a 80 column line. + exception = False + if Match(r' {6}\w', prev_line): # Initializer list? + # We are looking for the opening column of initializer list, which + # should be indented 4 spaces to cause 6 space indentation afterwards. + search_position = linenum-2 + while (search_position >= 0 + and Match(r' {6}\w', elided[search_position])): + search_position -= 1 + exception = (search_position >= 0 + and elided[search_position][:5] == ' :') + else: + # Search for the function arguments or an initializer list. We use a + # simple heuristic here: If the line is indented 4 spaces; and we have a + # closing paren, without the opening paren, followed by an opening brace + # or colon (for initializer lists) we assume that it is the last line of + # a function header. If we have a colon indented 4 spaces, it is an + # initializer list. + exception = (Match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)', + prev_line) + or Match(r' {4}:', prev_line)) + + if not exception: + error(filename, linenum, 'whitespace/blank_line', 2, + 'Redundant blank line at the start of a code block ' + 'should be deleted.') + # Ignore blank lines at the end of a block in a long if-else + # chain, like this: + # if (condition1) { + # // Something followed by a blank line + # + # } else if (condition2) { + # // Something else + # } + if linenum + 1 < clean_lines.NumLines(): + next_line = raw[linenum + 1] + if (next_line + and Match(r'\s*}', next_line) + and next_line.find('} else ') == -1): + error(filename, linenum, 'whitespace/blank_line', 3, + 'Redundant blank line at the end of a code block ' + 'should be deleted.') + + matched = Match(r'\s*(public|protected|private):', prev_line) + if matched: + error(filename, linenum, 'whitespace/blank_line', 3, + 'Do not leave a blank line after "%s:"' % matched.group(1)) + + # Next, check comments + next_line_start = 0 + if linenum + 1 < clean_lines.NumLines(): + next_line = raw[linenum + 1] + next_line_start = len(next_line) - len(next_line.lstrip()) + CheckComment(line, filename, linenum, next_line_start, error) + + # get rid of comments and strings + line = clean_lines.elided[linenum] + + # You shouldn't have spaces before your brackets, except maybe after + # 'delete []', 'return []() {};', or 'auto [abc, ...] = ...;'. + if Search(r'\w\s+\[', line) and not Search(r'(?:auto&?|delete|return)\s+\[', line): + error(filename, linenum, 'whitespace/braces', 5, + 'Extra space before [') + + # In range-based for, we wanted spaces before and after the colon, but + # not around "::" tokens that might appear. + if (Search(r'for *\(.*[^:]:[^: ]', line) or + Search(r'for *\(.*[^: ]:[^:]', line)): + error(filename, linenum, 'whitespace/forcolon', 2, + 'Missing space around colon in range-based for loop') + + +def CheckOperatorSpacing(filename, clean_lines, linenum, error): + """Checks for horizontal spacing around operators. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Don't try to do spacing checks for operator methods. Do this by + # replacing the troublesome characters with something else, + # preserving column position for all other characters. + # + # The replacement is done repeatedly to avoid false positives from + # operators that call operators. + while True: + match = Match(r'^(.*\boperator\b)(\S+)(\s*\(.*)$', line) + if match: + line = match.group(1) + ('_' * len(match.group(2))) + match.group(3) + else: + break + + # We allow no-spaces around = within an if: "if ( (a=Foo()) == 0 )". + # Otherwise not. Note we only check for non-spaces on *both* sides; + # sometimes people put non-spaces on one side when aligning ='s among + # many lines (not that this is behavior that I approve of...) + if ((Search(r'[\w.]=', line) or + Search(r'=[\w.]', line)) + and not Search(r'\b(if|while|for) ', line) + # Operators taken from [lex.operators] in C++11 standard. + and not Search(r'(>=|<=|==|!=|&=|\^=|\|=|\+=|\*=|\/=|\%=)', line) + and not Search(r'operator=', line)): + error(filename, linenum, 'whitespace/operators', 4, + 'Missing spaces around =') + + # It's ok not to have spaces around binary operators like + - * /, but if + # there's too little whitespace, we get concerned. It's hard to tell, + # though, so we punt on this one for now. TODO. + + # You should always have whitespace around binary operators. + # + # Check <= and >= first to avoid false positives with < and >, then + # check non-include lines for spacing around < and >. + # + # If the operator is followed by a comma, assume it's be used in a + # macro context and don't do any checks. This avoids false + # positives. + # + # Note that && is not included here. This is because there are too + # many false positives due to RValue references. + match = Search(r'[^<>=!\s](==|!=|<=|>=|\|\|)[^<>=!\s,;\)]', line) + if match: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around %s' % match.group(1)) + elif not Match(r'#.*include', line): + # Look for < that is not surrounded by spaces. This is only + # triggered if both sides are missing spaces, even though + # technically should should flag if at least one side is missing a + # space. This is done to avoid some false positives with shifts. + match = Match(r'^(.*[^\s<])<[^\s=<,]', line) + if match: + (_, _, end_pos) = CloseExpression( + clean_lines, linenum, len(match.group(1))) + if end_pos <= -1: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around <') + + # Look for > that is not surrounded by spaces. Similar to the + # above, we only trigger if both sides are missing spaces to avoid + # false positives with shifts. + match = Match(r'^(.*[^-\s>])>[^\s=>,]', line) + if match: + (_, _, start_pos) = ReverseCloseExpression( + clean_lines, linenum, len(match.group(1))) + if start_pos <= -1: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around >') + + # We allow no-spaces around << when used like this: 10<<20, but + # not otherwise (particularly, not when used as streams) + # + # We also allow operators following an opening parenthesis, since + # those tend to be macros that deal with operators. + match = Search(r'(operator|[^\s(<])(?:L|UL|LL|ULL|l|ul|ll|ull)?<<([^\s,=<])', line) + if (match and not (match.group(1).isdigit() and match.group(2).isdigit()) and + not (match.group(1) == 'operator' and match.group(2) == ';')): + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around <<') + + # We allow no-spaces around >> for almost anything. This is because + # C++11 allows ">>" to close nested templates, which accounts for + # most cases when ">>" is not followed by a space. + # + # We still warn on ">>" followed by alpha character, because that is + # likely due to ">>" being used for right shifts, e.g.: + # value >> alpha + # + # When ">>" is used to close templates, the alphanumeric letter that + # follows would be part of an identifier, and there should still be + # a space separating the template type and the identifier. + # type> alpha + match = Search(r'>>[a-zA-Z_]', line) + if match: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around >>') + + # There shouldn't be space around unary operators + match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line) + if match: + error(filename, linenum, 'whitespace/operators', 4, + 'Extra space for operator %s' % match.group(1)) + + +def CheckParenthesisSpacing(filename, clean_lines, linenum, error): + """Checks for horizontal spacing around parentheses. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # No spaces after an if, while, switch, or for + match = Search(r' (if\(|for\(|while\(|switch\()', line) + if match: + error(filename, linenum, 'whitespace/parens', 5, + 'Missing space before ( in %s' % match.group(1)) + + # For if/for/while/switch, the left and right parens should be + # consistent about how many spaces are inside the parens, and + # there should either be zero or one spaces inside the parens. + # We don't want: "if ( foo)" or "if ( foo )". + # Exception: "for ( ; foo; bar)" and "for (foo; bar; )" are allowed. + match = Search(r'\b(if|for|while|switch)\s*' + r'\(([ ]*)(.).*[^ ]+([ ]*)\)\s*{\s*$', + line) + if match: + if len(match.group(2)) != len(match.group(4)): + if not (match.group(3) == ';' and + len(match.group(2)) == 1 + len(match.group(4)) or + not match.group(2) and Search(r'\bfor\s*\(.*; \)', line)): + error(filename, linenum, 'whitespace/parens', 5, + 'Mismatching spaces inside () in %s' % match.group(1)) + if len(match.group(2)) not in [0, 1]: + error(filename, linenum, 'whitespace/parens', 5, + 'Should have zero or one spaces inside ( and ) in %s' % + match.group(1)) + + +def CheckCommaSpacing(filename, clean_lines, linenum, error): + """Checks for horizontal spacing near commas and semicolons. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + raw = clean_lines.lines_without_raw_strings + line = clean_lines.elided[linenum] + + # You should always have a space after a comma (either as fn arg or operator) + # + # This does not apply when the non-space character following the + # comma is another comma, since the only time when that happens is + # for empty macro arguments. + # + # We run this check in two passes: first pass on elided lines to + # verify that lines contain missing whitespaces, second pass on raw + # lines to confirm that those missing whitespaces are not due to + # elided comments. + if (Search(r',[^,\s]', ReplaceAll(r'\boperator\s*,\s*\(', 'F(', line)) and + Search(r',[^,\s]', raw[linenum])): + error(filename, linenum, 'whitespace/comma', 3, + 'Missing space after ,') + + # You should always have a space after a semicolon + # except for few corner cases + # TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more + # space after ; + if Search(r';[^\s};\\)/]', line): + error(filename, linenum, 'whitespace/semicolon', 3, + 'Missing space after ;') + + +def _IsType(clean_lines, nesting_state, expr): + """Check if expression looks like a type name, returns true if so. + + Args: + clean_lines: A CleansedLines instance containing the file. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + expr: The expression to check. + Returns: + True, if token looks like a type. + """ + # Keep only the last token in the expression + last_word = Match(r'^.*(\b\S+)$', expr) + if last_word: + token = last_word.group(1) + else: + token = expr + + # Match native types and stdint types + if _TYPES.match(token): + return True + + # Try a bit harder to match templated types. Walk up the nesting + # stack until we find something that resembles a typename + # declaration for what we are looking for. + typename_pattern = (r'\b(?:typename|class|struct)\s+' + re.escape(token) + + r'\b') + block_index = len(nesting_state.stack) - 1 + while block_index >= 0: + if isinstance(nesting_state.stack[block_index], _NamespaceInfo): + return False + + # Found where the opening brace is. We want to scan from this + # line up to the beginning of the function, minus a few lines. + # template + # class C + # : public ... { // start scanning here + last_line = nesting_state.stack[block_index].starting_linenum + + next_block_start = 0 + if block_index > 0: + next_block_start = nesting_state.stack[block_index - 1].starting_linenum + first_line = last_line + while first_line >= next_block_start: + if clean_lines.elided[first_line].find('template') >= 0: + break + first_line -= 1 + if first_line < next_block_start: + # Didn't find any "template" keyword before reaching the next block, + # there are probably no template things to check for this block + block_index -= 1 + continue + + # Look for typename in the specified range + for i in xrange(first_line, last_line + 1, 1): + if Search(typename_pattern, clean_lines.elided[i]): + return True + block_index -= 1 + + return False + + +def CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error): + """Checks for horizontal spacing near commas. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Except after an opening paren, or after another opening brace (in case of + # an initializer list, for instance), you should have spaces before your + # braces when they are delimiting blocks, classes, namespaces etc. + # And since you should never have braces at the beginning of a line, + # this is an easy test. Except that braces used for initialization don't + # follow the same rule; we often don't want spaces before those. + match = Match(r'^(.*[^ ({>]){', line) + + if match: + # Try a bit harder to check for brace initialization. This + # happens in one of the following forms: + # Constructor() : initializer_list_{} { ... } + # Constructor{}.MemberFunction() + # Type variable{}; + # FunctionCall(type{}, ...); + # LastArgument(..., type{}); + # LOG(INFO) << type{} << " ..."; + # map_of_type[{...}] = ...; + # ternary = expr ? new type{} : nullptr; + # OuterTemplate{}> + # + # We check for the character following the closing brace, and + # silence the warning if it's one of those listed above, i.e. + # "{.;,)<>]:". + # + # To account for nested initializer list, we allow any number of + # closing braces up to "{;,)<". We can't simply silence the + # warning on first sight of closing brace, because that would + # cause false negatives for things that are not initializer lists. + # Silence this: But not this: + # Outer{ if (...) { + # Inner{...} if (...){ // Missing space before { + # }; } + # + # There is a false negative with this approach if people inserted + # spurious semicolons, e.g. "if (cond){};", but we will catch the + # spurious semicolon with a separate check. + leading_text = match.group(1) + (endline, endlinenum, endpos) = CloseExpression( + clean_lines, linenum, len(match.group(1))) + trailing_text = '' + if endpos > -1: + trailing_text = endline[endpos:] + for offset in xrange(endlinenum + 1, + min(endlinenum + 3, clean_lines.NumLines() - 1)): + trailing_text += clean_lines.elided[offset] + # We also suppress warnings for `uint64_t{expression}` etc., as the style + # guide recommends brace initialization for integral types to avoid + # overflow/truncation. + if (not Match(r'^[\s}]*[{.;,)<>\]:]', trailing_text) + and not _IsType(clean_lines, nesting_state, leading_text)): + error(filename, linenum, 'whitespace/braces', 5, + 'Missing space before {') + + # Make sure '} else {' has spaces. + if Search(r'}else', line): + error(filename, linenum, 'whitespace/braces', 5, + 'Missing space before else') + + # You shouldn't have a space before a semicolon at the end of the line. + # There's a special case for "for" since the style guide allows space before + # the semicolon there. + if Search(r':\s*;\s*$', line): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Semicolon defining empty statement. Use {} instead.') + elif Search(r'^\s*;\s*$', line): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Line contains only semicolon. If this should be an empty statement, ' + 'use {} instead.') + elif (Search(r'\s+;\s*$', line) and + not Search(r'\bfor\b', line)): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Extra space before last semicolon. If this should be an empty ' + 'statement, use {} instead.') + + +def IsDecltype(clean_lines, linenum, column): + """Check if the token ending on (linenum, column) is decltype(). + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: the number of the line to check. + column: end column of the token to check. + Returns: + True if this token is decltype() expression, False otherwise. + """ + (text, _, start_col) = ReverseCloseExpression(clean_lines, linenum, column) + if start_col < 0: + return False + if Search(r'\bdecltype\s*$', text[0:start_col]): + return True + return False + +def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error): + """Checks for additional blank line issues related to sections. + + Currently the only thing checked here is blank line before protected/private. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + class_info: A _ClassInfo objects. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + # Skip checks if the class is small, where small means 25 lines or less. + # 25 lines seems like a good cutoff since that's the usual height of + # terminals, and any class that can't fit in one screen can't really + # be considered "small". + # + # Also skip checks if we are on the first line. This accounts for + # classes that look like + # class Foo { public: ... }; + # + # If we didn't find the end of the class, last_line would be zero, + # and the check will be skipped by the first condition. + if (class_info.last_line - class_info.starting_linenum <= 24 or + linenum <= class_info.starting_linenum): + return + + matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum]) + if matched: + # Issue warning if the line before public/protected/private was + # not a blank line, but don't do this if the previous line contains + # "class" or "struct". This can happen two ways: + # - We are at the beginning of the class. + # - We are forward-declaring an inner class that is semantically + # private, but needed to be public for implementation reasons. + # Also ignores cases where the previous line ends with a backslash as can be + # common when defining classes in C macros. + prev_line = clean_lines.lines[linenum - 1] + if (not IsBlankLine(prev_line) and + not Search(r'\b(class|struct)\b', prev_line) and + not Search(r'\\$', prev_line)): + # Try a bit harder to find the beginning of the class. This is to + # account for multi-line base-specifier lists, e.g.: + # class Derived + # : public Base { + end_class_head = class_info.starting_linenum + for i in range(class_info.starting_linenum, linenum): + if Search(r'\{\s*$', clean_lines.lines[i]): + end_class_head = i + break + if end_class_head < linenum - 1: + error(filename, linenum, 'whitespace/blank_line', 3, + '"%s:" should be preceded by a blank line' % matched.group(1)) + + +def GetPreviousNonBlankLine(clean_lines, linenum): + """Return the most recent non-blank line and its line number. + + Args: + clean_lines: A CleansedLines instance containing the file contents. + linenum: The number of the line to check. + + Returns: + A tuple with two elements. The first element is the contents of the last + non-blank line before the current line, or the empty string if this is the + first non-blank line. The second is the line number of that line, or -1 + if this is the first non-blank line. + """ + + prevlinenum = linenum - 1 + while prevlinenum >= 0: + prevline = clean_lines.elided[prevlinenum] + if not IsBlankLine(prevline): # if not a blank line... + return (prevline, prevlinenum) + prevlinenum -= 1 + return ('', -1) + + +def CheckBraces(filename, clean_lines, linenum, error): + """Looks for misplaced braces (e.g. at the end of line). + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + line = clean_lines.elided[linenum] # get rid of comments and strings + + if Match(r'\s*{\s*$', line): + # We allow an open brace to start a line in the case where someone is using + # braces in a block to explicitly create a new scope, which is commonly used + # to control the lifetime of stack-allocated variables. Braces are also + # used for brace initializers inside function calls. We don't detect this + # perfectly: we just don't complain if the last non-whitespace character on + # the previous non-blank line is ',', ';', ':', '(', '{', or '}', or if the + # previous line starts a preprocessor block. We also allow a brace on the + # following line if it is part of an array initialization and would not fit + # within the 80 character limit of the preceding line. + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] + if (not Search(r'[,;:}{(]\s*$', prevline) and + not Match(r'\s*#', prevline) and + not (GetLineWidth(prevline) > _line_length - 2 and '[]' in prevline)): + error(filename, linenum, 'whitespace/braces', 4, + '{ should almost always be at the end of the previous line') + + # An else clause should be on the same line as the preceding closing brace. + if Match(r'\s*else\b\s*(?:if\b|\{|$)', line): + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] + if Match(r'\s*}\s*$', prevline): + error(filename, linenum, 'whitespace/newline', 4, + 'An else should appear on the same line as the preceding }') + + # If braces come on one side of an else, they should be on both. + # However, we have to worry about "else if" that spans multiple lines! + if Search(r'else if\s*\(', line): # could be multi-line if + brace_on_left = bool(Search(r'}\s*else if\s*\(', line)) + # find the ( after the if + pos = line.find('else if') + pos = line.find('(', pos) + if pos > 0: + (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos) + brace_on_right = endline[endpos:].find('{') != -1 + if brace_on_left != brace_on_right: # must be brace after if + error(filename, linenum, 'readability/braces', 5, + 'If an else has a brace on one side, it should have it on both') + elif Search(r'}\s*else[^{]*$', line) or Match(r'[^}]*else\s*{', line): + error(filename, linenum, 'readability/braces', 5, + 'If an else has a brace on one side, it should have it on both') + + # Likewise, an else should never have the else clause on the same line + if Search(r'\belse [^\s{]', line) and not Search(r'\belse if\b', line): + error(filename, linenum, 'whitespace/newline', 4, + 'Else clause should never be on same line as else (use 2 lines)') + + # In the same way, a do/while should never be on one line + if Match(r'\s*do [^\s{]', line): + error(filename, linenum, 'whitespace/newline', 4, + 'do/while clauses should not be on a single line') + + # Check single-line if/else bodies. The style guide says 'curly braces are not + # required for single-line statements'. We additionally allow multi-line, + # single statements, but we reject anything with more than one semicolon in + # it. This means that the first semicolon after the if should be at the end of + # its line, and the line after that should have an indent level equal to or + # lower than the if. We also check for ambiguous if/else nesting without + # braces. + if_else_match = Search(r'\b(if\s*(|constexpr)\s*\(|else\b)', line) + if if_else_match and not Match(r'\s*#', line): + if_indent = GetIndentLevel(line) + endline, endlinenum, endpos = line, linenum, if_else_match.end() + if_match = Search(r'\bif\s*(|constexpr)\s*\(', line) + if if_match: + # This could be a multiline if condition, so find the end first. + pos = if_match.end() - 1 + (endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, pos) + # Check for an opening brace, either directly after the if or on the next + # line. If found, this isn't a single-statement conditional. + if (not Match(r'\s*{', endline[endpos:]) + and not (Match(r'\s*$', endline[endpos:]) + and endlinenum < (len(clean_lines.elided) - 1) + and Match(r'\s*{', clean_lines.elided[endlinenum + 1]))): + while (endlinenum < len(clean_lines.elided) + and ';' not in clean_lines.elided[endlinenum][endpos:]): + endlinenum += 1 + endpos = 0 + if endlinenum < len(clean_lines.elided): + endline = clean_lines.elided[endlinenum] + # We allow a mix of whitespace and closing braces (e.g. for one-liner + # methods) and a single \ after the semicolon (for macros) + endpos = endline.find(';') + if not Match(r';[\s}]*(\\?)$', endline[endpos:]): + # Semicolon isn't the last character, there's something trailing. + # Output a warning if the semicolon is not contained inside + # a lambda expression. + if not Match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}]*\}\s*\)*[;,]\s*$', + endline): + error(filename, linenum, 'readability/braces', 4, + 'If/else bodies with multiple statements require braces') + elif endlinenum < len(clean_lines.elided) - 1: + # Make sure the next line is dedented + next_line = clean_lines.elided[endlinenum + 1] + next_indent = GetIndentLevel(next_line) + # With ambiguous nested if statements, this will error out on the + # if that *doesn't* match the else, regardless of whether it's the + # inner one or outer one. + if (if_match and Match(r'\s*else\b', next_line) + and next_indent != if_indent): + error(filename, linenum, 'readability/braces', 4, + 'Else clause should be indented at the same level as if. ' + 'Ambiguous nested if/else chains require braces.') + elif next_indent > if_indent: + error(filename, linenum, 'readability/braces', 4, + 'If/else bodies with multiple statements require braces') + + +def CheckTrailingSemicolon(filename, clean_lines, linenum, error): + """Looks for redundant trailing semicolon. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + line = clean_lines.elided[linenum] + + # Block bodies should not be followed by a semicolon. Due to C++11 + # brace initialization, there are more places where semicolons are + # required than not, so we explicitly list the allowed rules rather + # than listing the disallowed ones. These are the places where "};" + # should be replaced by just "}": + # 1. Some flavor of block following closing parenthesis: + # for (;;) {}; + # while (...) {}; + # switch (...) {}; + # Function(...) {}; + # if (...) {}; + # if (...) else if (...) {}; + # + # 2. else block: + # if (...) else {}; + # + # 3. const member function: + # Function(...) const {}; + # + # 4. Block following some statement: + # x = 42; + # {}; + # + # 5. Block at the beginning of a function: + # Function(...) { + # {}; + # } + # + # Note that naively checking for the preceding "{" will also match + # braces inside multi-dimensional arrays, but this is fine since + # that expression will not contain semicolons. + # + # 6. Block following another block: + # while (true) {} + # {}; + # + # 7. End of namespaces: + # namespace {}; + # + # These semicolons seems far more common than other kinds of + # redundant semicolons, possibly due to people converting classes + # to namespaces. For now we do not warn for this case. + # + # Try matching case 1 first. + match = Match(r'^(.*\)\s*)\{', line) + if match: + # Matched closing parenthesis (case 1). Check the token before the + # matching opening parenthesis, and don't warn if it looks like a + # macro. This avoids these false positives: + # - macro that defines a base class + # - multi-line macro that defines a base class + # - macro that defines the whole class-head + # + # But we still issue warnings for macros that we know are safe to + # warn, specifically: + # - TEST, TEST_F, TEST_P, MATCHER, MATCHER_P + # - TYPED_TEST + # - INTERFACE_DEF + # - EXCLUSIVE_LOCKS_REQUIRED, SHARED_LOCKS_REQUIRED, LOCKS_EXCLUDED: + # + # We implement a list of safe macros instead of a list of + # unsafe macros, even though the latter appears less frequently in + # google code and would have been easier to implement. This is because + # the downside for getting the allowed checks wrong means some extra + # semicolons, while the downside for getting disallowed checks wrong + # would result in compile errors. + # + # In addition to macros, we also don't want to warn on + # - Compound literals + # - Lambdas + # - alignas specifier with anonymous structs + # - decltype + closing_brace_pos = match.group(1).rfind(')') + opening_parenthesis = ReverseCloseExpression( + clean_lines, linenum, closing_brace_pos) + if opening_parenthesis[2] > -1: + line_prefix = opening_parenthesis[0][0:opening_parenthesis[2]] + macro = Search(r'\b([A-Z_][A-Z0-9_]*)\s*$', line_prefix) + func = Match(r'^(.*\])\s*$', line_prefix) + if ((macro and + macro.group(1) not in ( + 'TEST', 'TEST_F', 'MATCHER', 'MATCHER_P', 'TYPED_TEST', + 'EXCLUSIVE_LOCKS_REQUIRED', 'SHARED_LOCKS_REQUIRED', + 'LOCKS_EXCLUDED', 'INTERFACE_DEF')) or + (func and not Search(r'\boperator\s*\[\s*\]', func.group(1))) or + Search(r'\b(?:struct|union)\s+alignas\s*$', line_prefix) or + Search(r'\bdecltype$', line_prefix) or + Search(r'\s+=\s*$', line_prefix)): + match = None + if (match and + opening_parenthesis[1] > 1 and + Search(r'\]\s*$', clean_lines.elided[opening_parenthesis[1] - 1])): + # Multi-line lambda-expression + match = None + + else: + # Try matching cases 2-3. + match = Match(r'^(.*(?:else|\)\s*const)\s*)\{', line) + if not match: + # Try matching cases 4-6. These are always matched on separate lines. + # + # Note that we can't simply concatenate the previous line to the + # current line and do a single match, otherwise we may output + # duplicate warnings for the blank line case: + # if (cond) { + # // blank line + # } + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] + if prevline and Search(r'[;{}]\s*$', prevline): + match = Match(r'^(\s*)\{', line) + + # Check matching closing brace + if match: + (endline, endlinenum, endpos) = CloseExpression( + clean_lines, linenum, len(match.group(1))) + if endpos > -1 and Match(r'^\s*;', endline[endpos:]): + # Current {} pair is eligible for semicolon check, and we have found + # the redundant semicolon, output warning here. + # + # Note: because we are scanning forward for opening braces, and + # outputting warnings for the matching closing brace, if there are + # nested blocks with trailing semicolons, we will get the error + # messages in reversed order. + + # We need to check the line forward for NOLINT + raw_lines = clean_lines.raw_lines + ParseNolintSuppressions(filename, raw_lines[endlinenum-1], endlinenum-1, + error) + ParseNolintSuppressions(filename, raw_lines[endlinenum], endlinenum, + error) + + error(filename, endlinenum, 'readability/braces', 4, + "You don't need a ; after a }") + + +def CheckEmptyBlockBody(filename, clean_lines, linenum, error): + """Look for empty loop/conditional body with only a single semicolon. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + # Search for loop keywords at the beginning of the line. Because only + # whitespaces are allowed before the keywords, this will also ignore most + # do-while-loops, since those lines should start with closing brace. + # + # We also check "if" blocks here, since an empty conditional block + # is likely an error. + line = clean_lines.elided[linenum] + matched = Match(r'\s*(for|while|if)\s*\(', line) + if matched: + # Find the end of the conditional expression. + (end_line, end_linenum, end_pos) = CloseExpression( + clean_lines, linenum, line.find('(')) + + # Output warning if what follows the condition expression is a semicolon. + # No warning for all other cases, including whitespace or newline, since we + # have a separate check for semicolons preceded by whitespace. + if end_pos >= 0 and Match(r';', end_line[end_pos:]): + if matched.group(1) == 'if': + error(filename, end_linenum, 'whitespace/empty_conditional_body', 5, + 'Empty conditional bodies should use {}') + else: + error(filename, end_linenum, 'whitespace/empty_loop_body', 5, + 'Empty loop bodies should use {} or continue') + + # Check for if statements that have completely empty bodies (no comments) + # and no else clauses. + if end_pos >= 0 and matched.group(1) == 'if': + # Find the position of the opening { for the if statement. + # Return without logging an error if it has no brackets. + opening_linenum = end_linenum + opening_line_fragment = end_line[end_pos:] + # Loop until EOF or find anything that's not whitespace or opening {. + while not Search(r'^\s*\{', opening_line_fragment): + if Search(r'^(?!\s*$)', opening_line_fragment): + # Conditional has no brackets. + return + opening_linenum += 1 + if opening_linenum == len(clean_lines.elided): + # Couldn't find conditional's opening { or any code before EOF. + return + opening_line_fragment = clean_lines.elided[opening_linenum] + # Set opening_line (opening_line_fragment may not be entire opening line). + opening_line = clean_lines.elided[opening_linenum] + + # Find the position of the closing }. + opening_pos = opening_line_fragment.find('{') + if opening_linenum == end_linenum: + # We need to make opening_pos relative to the start of the entire line. + opening_pos += end_pos + (closing_line, closing_linenum, closing_pos) = CloseExpression( + clean_lines, opening_linenum, opening_pos) + if closing_pos < 0: + return + + # Now construct the body of the conditional. This consists of the portion + # of the opening line after the {, all lines until the closing line, + # and the portion of the closing line before the }. + if (clean_lines.raw_lines[opening_linenum] != + CleanseComments(clean_lines.raw_lines[opening_linenum])): + # Opening line ends with a comment, so conditional isn't empty. + return + if closing_linenum > opening_linenum: + # Opening line after the {. Ignore comments here since we checked above. + bodylist = list(opening_line[opening_pos+1:]) + # All lines until closing line, excluding closing line, with comments. + bodylist.extend(clean_lines.raw_lines[opening_linenum+1:closing_linenum]) + # Closing line before the }. Won't (and can't) have comments. + bodylist.append(clean_lines.elided[closing_linenum][:closing_pos-1]) + body = '\n'.join(bodylist) + else: + # If statement has brackets and fits on a single line. + body = opening_line[opening_pos+1:closing_pos-1] + + # Check if the body is empty + if not _EMPTY_CONDITIONAL_BODY_PATTERN.search(body): + return + # The body is empty. Now make sure there's not an else clause. + current_linenum = closing_linenum + current_line_fragment = closing_line[closing_pos:] + # Loop until EOF or find anything that's not whitespace or else clause. + while Search(r'^\s*$|^(?=\s*else)', current_line_fragment): + if Search(r'^(?=\s*else)', current_line_fragment): + # Found an else clause, so don't log an error. + return + current_linenum += 1 + if current_linenum == len(clean_lines.elided): + break + current_line_fragment = clean_lines.elided[current_linenum] + + # The body is empty and there's no else clause until EOF or other code. + error(filename, end_linenum, 'whitespace/empty_if_body', 4, + ('If statement had no body and no else clause')) + + +def FindCheckMacro(line): + """Find a replaceable CHECK-like macro. + + Args: + line: line to search on. + Returns: + (macro name, start position), or (None, -1) if no replaceable + macro is found. + """ + for macro in _CHECK_MACROS: + i = line.find(macro) + if i >= 0: + # Find opening parenthesis. Do a regular expression match here + # to make sure that we are matching the expected CHECK macro, as + # opposed to some other macro that happens to contain the CHECK + # substring. + matched = Match(r'^(.*\b' + macro + r'\s*)\(', line) + if not matched: + continue + return (macro, len(matched.group(1))) + return (None, -1) + + +def CheckCheck(filename, clean_lines, linenum, error): + """Checks the use of CHECK and EXPECT macros. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + # Decide the set of replacement macros that should be suggested + lines = clean_lines.elided + (check_macro, start_pos) = FindCheckMacro(lines[linenum]) + if not check_macro: + return + + # Find end of the boolean expression by matching parentheses + (last_line, end_line, end_pos) = CloseExpression( + clean_lines, linenum, start_pos) + if end_pos < 0: + return + + # If the check macro is followed by something other than a + # semicolon, assume users will log their own custom error messages + # and don't suggest any replacements. + if not Match(r'\s*;', last_line[end_pos:]): + return + + if linenum == end_line: + expression = lines[linenum][start_pos + 1:end_pos - 1] + else: + expression = lines[linenum][start_pos + 1:] + for i in xrange(linenum + 1, end_line): + expression += lines[i] + expression += last_line[0:end_pos - 1] + + # Parse expression so that we can take parentheses into account. + # This avoids false positives for inputs like "CHECK((a < 4) == b)", + # which is not replaceable by CHECK_LE. + lhs = '' + rhs = '' + operator = None + while expression: + matched = Match(r'^\s*(<<|<<=|>>|>>=|->\*|->|&&|\|\||' + r'==|!=|>=|>|<=|<|\()(.*)$', expression) + if matched: + token = matched.group(1) + if token == '(': + # Parenthesized operand + expression = matched.group(2) + (end, _) = FindEndOfExpressionInLine(expression, 0, ['(']) + if end < 0: + return # Unmatched parenthesis + lhs += '(' + expression[0:end] + expression = expression[end:] + elif token in ('&&', '||'): + # Logical and/or operators. This means the expression + # contains more than one term, for example: + # CHECK(42 < a && a < b); + # + # These are not replaceable with CHECK_LE, so bail out early. + return + elif token in ('<<', '<<=', '>>', '>>=', '->*', '->'): + # Non-relational operator + lhs += token + expression = matched.group(2) + else: + # Relational operator + operator = token + rhs = matched.group(2) + break + else: + # Unparenthesized operand. Instead of appending to lhs one character + # at a time, we do another regular expression match to consume several + # characters at once if possible. Trivial benchmark shows that this + # is more efficient when the operands are longer than a single + # character, which is generally the case. + matched = Match(r'^([^-=!<>()&|]+)(.*)$', expression) + if not matched: + matched = Match(r'^(\s*\S)(.*)$', expression) + if not matched: + break + lhs += matched.group(1) + expression = matched.group(2) + + # Only apply checks if we got all parts of the boolean expression + if not (lhs and operator and rhs): + return + + # Check that rhs do not contain logical operators. We already know + # that lhs is fine since the loop above parses out && and ||. + if rhs.find('&&') > -1 or rhs.find('||') > -1: + return + + # At least one of the operands must be a constant literal. This is + # to avoid suggesting replacements for unprintable things like + # CHECK(variable != iterator) + # + # The following pattern matches decimal, hex integers, strings, and + # characters (in that order). + lhs = lhs.strip() + rhs = rhs.strip() + match_constant = r'^([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')$' + if Match(match_constant, lhs) or Match(match_constant, rhs): + # Note: since we know both lhs and rhs, we can provide a more + # descriptive error message like: + # Consider using CHECK_EQ(x, 42) instead of CHECK(x == 42) + # Instead of: + # Consider using CHECK_EQ instead of CHECK(a == b) + # + # We are still keeping the less descriptive message because if lhs + # or rhs gets long, the error message might become unreadable. + error(filename, linenum, 'readability/check', 2, + 'Consider using %s instead of %s(a %s b)' % ( + _CHECK_REPLACEMENT[check_macro][operator], + check_macro, operator)) + + +def CheckAltTokens(filename, clean_lines, linenum, error): + """Check alternative keywords being used in boolean expressions. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Avoid preprocessor lines + if Match(r'^\s*#', line): + return + + # Last ditch effort to avoid multi-line comments. This will not help + # if the comment started before the current line or ended after the + # current line, but it catches most of the false positives. At least, + # it provides a way to workaround this warning for people who use + # multi-line comments in preprocessor macros. + # + # TODO(unknown): remove this once cpplint has better support for + # multi-line comments. + if line.find('/*') >= 0 or line.find('*/') >= 0: + return + + for match in _ALT_TOKEN_REPLACEMENT_PATTERN.finditer(line): + error(filename, linenum, 'readability/alt_tokens', 2, + 'Use operator %s instead of %s' % ( + _ALT_TOKEN_REPLACEMENT[match.group(1)], match.group(1))) + + +def GetLineWidth(line): + """Determines the width of the line in column positions. + + Args: + line: A string, which may be a Unicode string. + + Returns: + The width of the line in column positions, accounting for Unicode + combining characters and wide characters. + """ + if isinstance(line, unicode): + width = 0 + for uc in unicodedata.normalize('NFC', line): + if unicodedata.east_asian_width(uc) in ('W', 'F'): + width += 2 + elif not unicodedata.combining(uc): + # Issue 337 + # https://mail.python.org/pipermail/python-list/2012-August/628809.html + if (sys.version_info.major, sys.version_info.minor) <= (3, 2): + # https://github.com/python/cpython/blob/2.7/Include/unicodeobject.h#L81 + is_wide_build = sysconfig.get_config_var("Py_UNICODE_SIZE") >= 4 + # https://github.com/python/cpython/blob/2.7/Objects/unicodeobject.c#L564 + is_low_surrogate = 0xDC00 <= ord(uc) <= 0xDFFF + if not is_wide_build and is_low_surrogate: + width -= 1 + + width += 1 + return width + else: + return len(line) + + +def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state, + error): + """Checks rules from the 'C++ style rules' section of cppguide.html. + + Most of these rules are hard to test (naming, comment style), but we + do what we can. In particular we check for 2-space indents, line lengths, + tab usage, spaces inside code, etc. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + file_extension: The extension (without the dot) of the filename. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + + # Don't use "elided" lines here, otherwise we can't check commented lines. + # Don't want to use "raw" either, because we don't want to check inside C++11 + # raw strings, + raw_lines = clean_lines.lines_without_raw_strings + line = raw_lines[linenum] + prev = raw_lines[linenum - 1] if linenum > 0 else '' + + if line.find('\t') != -1: + error(filename, linenum, 'whitespace/tab', 1, + 'Tab found; better to use spaces') + + # One or three blank spaces at the beginning of the line is weird; it's + # hard to reconcile that with 2-space indents. + # NOTE: here are the conditions rob pike used for his tests. Mine aren't + # as sophisticated, but it may be worth becoming so: RLENGTH==initial_spaces + # if(RLENGTH > 20) complain = 0; + # if(match($0, " +(error|private|public|protected):")) complain = 0; + # if(match(prev, "&& *$")) complain = 0; + # if(match(prev, "\\|\\| *$")) complain = 0; + # if(match(prev, "[\",=><] *$")) complain = 0; + # if(match($0, " <<")) complain = 0; + # if(match(prev, " +for \\(")) complain = 0; + # if(prevodd && match(prevprev, " +for \\(")) complain = 0; + scope_or_label_pattern = r'\s*(?:public|private|protected|signals)(?:\s+(?:slots\s*)?)?:\s*\\?$' + classinfo = nesting_state.InnermostClass() + initial_spaces = 0 + cleansed_line = clean_lines.elided[linenum] + while initial_spaces < len(line) and line[initial_spaces] == ' ': + initial_spaces += 1 + # There are certain situations we allow one space, notably for + # section labels, and also lines containing multi-line raw strings. + # We also don't check for lines that look like continuation lines + # (of lines ending in double quotes, commas, equals, or angle brackets) + # because the rules for how to indent those are non-trivial. + if (not Search(r'[",=><] *$', prev) and + (initial_spaces == 1 or initial_spaces == 3) and + not Match(scope_or_label_pattern, cleansed_line) and + not (clean_lines.raw_lines[linenum] != line and + Match(r'^\s*""', line))): + error(filename, linenum, 'whitespace/indent', 3, + 'Weird number of spaces at line-start. ' + 'Are you using a 2-space indent?') + + if line and line[-1].isspace(): + error(filename, linenum, 'whitespace/end_of_line', 4, + 'Line ends in whitespace. Consider deleting these extra spaces.') + + # Check if the line is a header guard. + is_header_guard = False + if IsHeaderExtension(file_extension): + cppvar = GetHeaderGuardCPPVariable(filename) + if (line.startswith('#ifndef %s' % cppvar) or + line.startswith('#define %s' % cppvar) or + line.startswith('#endif // %s' % cppvar)): + is_header_guard = True + # #include lines and header guards can be long, since there's no clean way to + # split them. + # + # URLs can be long too. It's possible to split these, but it makes them + # harder to cut&paste. + # + # The "$Id:...$" comment may also get very long without it being the + # developers fault. + # + # Doxygen documentation copying can get pretty long when using an overloaded + # function declaration + if (not line.startswith('#include') and not is_header_guard and + not Match(r'^\s*//.*http(s?)://\S*$', line) and + not Match(r'^\s*//\s*[^\s]*$', line) and + not Match(r'^// \$Id:.*#[0-9]+ \$$', line) and + not Match(r'^\s*/// [@\\](copydoc|copydetails|copybrief) .*$', line)): + line_width = GetLineWidth(line) + if line_width > _line_length: + error(filename, linenum, 'whitespace/line_length', 2, + 'Lines should be <= %i characters long' % _line_length) + + if (cleansed_line.count(';') > 1 and + # allow simple single line lambdas + not Match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}\n\r]*\}', + line) and + # for loops are allowed two ;'s (and may run over two lines). + cleansed_line.find('for') == -1 and + (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or + GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and + # It's ok to have many commands in a switch case that fits in 1 line + not ((cleansed_line.find('case ') != -1 or + cleansed_line.find('default:') != -1) and + cleansed_line.find('break;') != -1)): + error(filename, linenum, 'whitespace/newline', 0, + 'More than one command on the same line') + + # Some more style checks + CheckBraces(filename, clean_lines, linenum, error) + CheckTrailingSemicolon(filename, clean_lines, linenum, error) + CheckEmptyBlockBody(filename, clean_lines, linenum, error) + CheckSpacing(filename, clean_lines, linenum, nesting_state, error) + CheckOperatorSpacing(filename, clean_lines, linenum, error) + CheckParenthesisSpacing(filename, clean_lines, linenum, error) + CheckCommaSpacing(filename, clean_lines, linenum, error) + CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error) + CheckSpacingForFunctionCall(filename, clean_lines, linenum, error) + CheckCheck(filename, clean_lines, linenum, error) + CheckAltTokens(filename, clean_lines, linenum, error) + classinfo = nesting_state.InnermostClass() + if classinfo: + CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error) + + +_RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$') +# Matches the first component of a filename delimited by -s and _s. That is: +# _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo.cc').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo-bar_baz.cc').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo_bar-baz.cc').group(0) == 'foo' +_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+') + + +def _DropCommonSuffixes(filename): + """Drops common suffixes like _test.cc or -inl.h from filename. + + For example: + >>> _DropCommonSuffixes('foo/foo-inl.h') + 'foo/foo' + >>> _DropCommonSuffixes('foo/bar/foo.cc') + 'foo/bar/foo' + >>> _DropCommonSuffixes('foo/foo_internal.h') + 'foo/foo' + >>> _DropCommonSuffixes('foo/foo_unusualinternal.h') + 'foo/foo_unusualinternal' + + Args: + filename: The input filename. + + Returns: + The filename with the common suffix removed. + """ + for suffix in itertools.chain( + ('%s.%s' % (test_suffix.lstrip('_'), ext) + for test_suffix, ext in itertools.product(_test_suffixes, GetNonHeaderExtensions())), + ('%s.%s' % (suffix, ext) + for suffix, ext in itertools.product(['inl', 'imp', 'internal'], GetHeaderExtensions()))): + if (filename.endswith(suffix) and len(filename) > len(suffix) and + filename[-len(suffix) - 1] in ('-', '_')): + return filename[:-len(suffix) - 1] + return os.path.splitext(filename)[0] + + +def _ClassifyInclude(fileinfo, include, used_angle_brackets, include_order="default"): + """Figures out what kind of header 'include' is. + + Args: + fileinfo: The current file cpplint is running over. A FileInfo instance. + include: The path to a #included file. + used_angle_brackets: True if the #include used <> rather than "". + include_order: "default" or other value allowed in program arguments + + Returns: + One of the _XXX_HEADER constants. + + For example: + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True) + _C_SYS_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True) + _CPP_SYS_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', True, "standardcfirst") + _OTHER_SYS_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False) + _LIKELY_MY_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'), + ... 'bar/foo_other_ext.h', False) + _POSSIBLE_MY_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False) + _OTHER_HEADER + """ + # This is a list of all standard c++ header files, except + # those already checked for above. + is_cpp_header = include in _CPP_HEADERS + + # Mark include as C header if in list or in a known folder for standard-ish C headers. + is_std_c_header = (include_order == "default") or (include in _C_HEADERS + # additional linux glibc header folders + or Search(r'(?:%s)\/.*\.h' % "|".join(C_STANDARD_HEADER_FOLDERS), include)) + + # Headers with C++ extensions shouldn't be considered C system headers + is_system = used_angle_brackets and not os.path.splitext(include)[1] in ['.hpp', '.hxx', '.h++'] + + if is_system: + if is_cpp_header: + return _CPP_SYS_HEADER + if is_std_c_header: + return _C_SYS_HEADER + else: + return _OTHER_SYS_HEADER + + # If the target file and the include we're checking share a + # basename when we drop common extensions, and the include + # lives in . , then it's likely to be owned by the target file. + target_dir, target_base = ( + os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName()))) + include_dir, include_base = os.path.split(_DropCommonSuffixes(include)) + target_dir_pub = os.path.normpath(target_dir + '/../public') + target_dir_pub = target_dir_pub.replace('\\', '/') + if target_base == include_base and ( + include_dir == target_dir or + include_dir == target_dir_pub): + return _LIKELY_MY_HEADER + + # If the target and include share some initial basename + # component, it's possible the target is implementing the + # include, so it's allowed to be first, but we'll never + # complain if it's not there. + target_first_component = _RE_FIRST_COMPONENT.match(target_base) + include_first_component = _RE_FIRST_COMPONENT.match(include_base) + if (target_first_component and include_first_component and + target_first_component.group(0) == + include_first_component.group(0)): + return _POSSIBLE_MY_HEADER + + return _OTHER_HEADER + + + +def CheckIncludeLine(filename, clean_lines, linenum, include_state, error): + """Check rules that are applicable to #include lines. + + Strings on #include lines are NOT removed from elided line, to make + certain tasks easier. However, to prevent false positives, checks + applicable to #include lines in CheckLanguage must be put here. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + include_state: An _IncludeState instance in which the headers are inserted. + error: The function to call with any errors found. + """ + fileinfo = FileInfo(filename) + line = clean_lines.lines[linenum] + + # "include" should use the new style "foo/bar.h" instead of just "bar.h" + # Only do this check if the included header follows google naming + # conventions. If not, assume that it's a 3rd party API that + # requires special include conventions. + # + # We also make an exception for Lua headers, which follow google + # naming convention but not the include convention. + match = Match(r'#include\s*"([^/]+\.h)"', line) + if match and not _THIRD_PARTY_HEADERS_PATTERN.match(match.group(1)): + error(filename, linenum, 'build/include_subdir', 4, + 'Include the directory when naming .h files') + + # we shouldn't include a file more than once. actually, there are a + # handful of instances where doing so is okay, but in general it's + # not. + match = _RE_PATTERN_INCLUDE.search(line) + if match: + include = match.group(2) + used_angle_brackets = (match.group(1) == '<') + duplicate_line = include_state.FindHeader(include) + if duplicate_line >= 0: + error(filename, linenum, 'build/include', 4, + '"%s" already included at %s:%s' % + (include, filename, duplicate_line)) + return + + for extension in GetNonHeaderExtensions(): + if (include.endswith('.' + extension) and + os.path.dirname(fileinfo.RepositoryName()) != os.path.dirname(include)): + error(filename, linenum, 'build/include', 4, + 'Do not include .' + extension + ' files from other packages') + return + + # We DO want to include a 3rd party looking header if it matches the + # filename. Otherwise we get an erroneous error "...should include its + # header" error later. + third_src_header = False + for ext in GetHeaderExtensions(): + basefilename = filename[0:len(filename) - len(fileinfo.Extension())] + headerfile = basefilename + '.' + ext + headername = FileInfo(headerfile).RepositoryName() + if headername in include or include in headername: + third_src_header = True + break + + if third_src_header or not _THIRD_PARTY_HEADERS_PATTERN.match(include): + include_state.include_list[-1].append((include, linenum)) + + # We want to ensure that headers appear in the right order: + # 1) for foo.cc, foo.h (preferred location) + # 2) c system files + # 3) cpp system files + # 4) for foo.cc, foo.h (deprecated location) + # 5) other google headers + # + # We classify each include statement as one of those 5 types + # using a number of techniques. The include_state object keeps + # track of the highest type seen, and complains if we see a + # lower type after that. + error_message = include_state.CheckNextIncludeOrder( + _ClassifyInclude(fileinfo, include, used_angle_brackets, _include_order)) + if error_message: + error(filename, linenum, 'build/include_order', 4, + '%s. Should be: %s.h, c system, c++ system, other.' % + (error_message, fileinfo.BaseName())) + canonical_include = include_state.CanonicalizeAlphabeticalOrder(include) + if not include_state.IsInAlphabeticalOrder( + clean_lines, linenum, canonical_include): + error(filename, linenum, 'build/include_alpha', 4, + 'Include "%s" not in alphabetical order' % include) + include_state.SetLastHeader(canonical_include) + + + +def _GetTextInside(text, start_pattern): + r"""Retrieves all the text between matching open and close parentheses. + + Given a string of lines and a regular expression string, retrieve all the text + following the expression and between opening punctuation symbols like + (, [, or {, and the matching close-punctuation symbol. This properly nested + occurrences of the punctuations, so for the text like + printf(a(), b(c())); + a call to _GetTextInside(text, r'printf\(') will return 'a(), b(c())'. + start_pattern must match string having an open punctuation symbol at the end. + + Args: + text: The lines to extract text. Its comments and strings must be elided. + It can be single line and can span multiple lines. + start_pattern: The regexp string indicating where to start extracting + the text. + Returns: + The extracted text. + None if either the opening string or ending punctuation could not be found. + """ + # TODO(unknown): Audit cpplint.py to see what places could be profitably + # rewritten to use _GetTextInside (and use inferior regexp matching today). + + # Give opening punctuations to get the matching close-punctuations. + matching_punctuation = {'(': ')', '{': '}', '[': ']'} + closing_punctuation = set(itervalues(matching_punctuation)) + + # Find the position to start extracting text. + match = re.search(start_pattern, text, re.M) + if not match: # start_pattern not found in text. + return None + start_position = match.end(0) + + assert start_position > 0, ( + 'start_pattern must ends with an opening punctuation.') + assert text[start_position - 1] in matching_punctuation, ( + 'start_pattern must ends with an opening punctuation.') + # Stack of closing punctuations we expect to have in text after position. + punctuation_stack = [matching_punctuation[text[start_position - 1]]] + position = start_position + while punctuation_stack and position < len(text): + if text[position] == punctuation_stack[-1]: + punctuation_stack.pop() + elif text[position] in closing_punctuation: + # A closing punctuation without matching opening punctuations. + return None + elif text[position] in matching_punctuation: + punctuation_stack.append(matching_punctuation[text[position]]) + position += 1 + if punctuation_stack: + # Opening punctuations left without matching close-punctuations. + return None + # punctuations match. + return text[start_position:position - 1] + + +# Patterns for matching call-by-reference parameters. +# +# Supports nested templates up to 2 levels deep using this messy pattern: +# < (?: < (?: < [^<>]* +# > +# | [^<>] )* +# > +# | [^<>] )* +# > +_RE_PATTERN_IDENT = r'[_a-zA-Z]\w*' # =~ [[:alpha:]][[:alnum:]]* +_RE_PATTERN_TYPE = ( + r'(?:const\s+)?(?:typename\s+|class\s+|struct\s+|union\s+|enum\s+)?' + r'(?:\w|' + r'\s*<(?:<(?:<[^<>]*>|[^<>])*>|[^<>])*>|' + r'::)+') +# A call-by-reference parameter ends with '& identifier'. +_RE_PATTERN_REF_PARAM = re.compile( + r'(' + _RE_PATTERN_TYPE + r'(?:\s*(?:\bconst\b|[*]))*\s*' + r'&\s*' + _RE_PATTERN_IDENT + r')\s*(?:=[^,()]+)?[,)]') +# A call-by-const-reference parameter either ends with 'const& identifier' +# or looks like 'const type& identifier' when 'type' is atomic. +_RE_PATTERN_CONST_REF_PARAM = ( + r'(?:.*\s*\bconst\s*&\s*' + _RE_PATTERN_IDENT + + r'|const\s+' + _RE_PATTERN_TYPE + r'\s*&\s*' + _RE_PATTERN_IDENT + r')') +# Stream types. +_RE_PATTERN_REF_STREAM_PARAM = ( + r'(?:.*stream\s*&\s*' + _RE_PATTERN_IDENT + r')') + + +def CheckLanguage(filename, clean_lines, linenum, file_extension, + include_state, nesting_state, error): + """Checks rules from the 'C++ language rules' section of cppguide.html. + + Some of these rules are hard to test (function overloading, using + uint32 inappropriately), but we do the best we can. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + file_extension: The extension (without the dot) of the filename. + include_state: An _IncludeState instance in which the headers are inserted. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + # If the line is empty or consists of entirely a comment, no need to + # check it. + line = clean_lines.elided[linenum] + if not line: + return + + match = _RE_PATTERN_INCLUDE.search(line) + if match: + CheckIncludeLine(filename, clean_lines, linenum, include_state, error) + return + + # Reset include state across preprocessor directives. This is meant + # to silence warnings for conditional includes. + match = Match(r'^\s*#\s*(if|ifdef|ifndef|elif|else|endif)\b', line) + if match: + include_state.ResetSection(match.group(1)) + + + # Perform other checks now that we are sure that this is not an include line + CheckCasts(filename, clean_lines, linenum, error) + CheckGlobalStatic(filename, clean_lines, linenum, error) + CheckPrintf(filename, clean_lines, linenum, error) + + if IsHeaderExtension(file_extension): + # TODO(unknown): check that 1-arg constructors are explicit. + # How to tell it's a constructor? + # (handled in CheckForNonStandardConstructs for now) + # TODO(unknown): check that classes declare or disable copy/assign + # (level 1 error) + pass + + # Check if people are using the verboten C basic types. The only exception + # we regularly allow is "unsigned short port" for port. + if Search(r'\bshort port\b', line): + if not Search(r'\bunsigned short port\b', line): + error(filename, linenum, 'runtime/int', 4, + 'Use "unsigned short" for ports, not "short"') + else: + match = Search(r'\b(short|long(?! +double)|long long)\b', line) + if match: + error(filename, linenum, 'runtime/int', 4, + 'Use int16/int64/etc, rather than the C type %s' % match.group(1)) + + # Check if some verboten operator overloading is going on + # TODO(unknown): catch out-of-line unary operator&: + # class X {}; + # int operator&(const X& x) { return 42; } // unary operator& + # The trick is it's hard to tell apart from binary operator&: + # class Y { int operator&(const Y& x) { return 23; } }; // binary operator& + if Search(r'\boperator\s*&\s*\(\s*\)', line): + error(filename, linenum, 'runtime/operator', 4, + 'Unary operator& is dangerous. Do not use it.') + + # Check for suspicious usage of "if" like + # } if (a == b) { + if Search(r'\}\s*if\s*\(', line): + error(filename, linenum, 'readability/braces', 4, + 'Did you mean "else if"? If not, start a new line for "if".') + + # Check for potential format string bugs like printf(foo). + # We constrain the pattern not to pick things like DocidForPrintf(foo). + # Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str()) + # TODO(unknown): Catch the following case. Need to change the calling + # convention of the whole function to process multiple line to handle it. + # printf( + # boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line); + printf_args = _GetTextInside(line, r'(?i)\b(string)?printf\s*\(') + if printf_args: + match = Match(r'([\w.\->()]+)$', printf_args) + if match and match.group(1) != '__VA_ARGS__': + function_name = re.search(r'\b((?:string)?printf)\s*\(', + line, re.I).group(1) + error(filename, linenum, 'runtime/printf', 4, + 'Potential format string bug. Do %s("%%s", %s) instead.' + % (function_name, match.group(1))) + + # Check for potential memset bugs like memset(buf, sizeof(buf), 0). + match = Search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line) + if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)): + error(filename, linenum, 'runtime/memset', 4, + 'Did you mean "memset(%s, 0, %s)"?' + % (match.group(1), match.group(2))) + + if Search(r'\busing namespace\b', line): + if Search(r'\bliterals\b', line): + error(filename, linenum, 'build/namespaces_literals', 5, + 'Do not use namespace using-directives. ' + 'Use using-declarations instead.') + else: + error(filename, linenum, 'build/namespaces', 5, + 'Do not use namespace using-directives. ' + 'Use using-declarations instead.') + + # Detect variable-length arrays. + match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line) + if (match and match.group(2) != 'return' and match.group(2) != 'delete' and + match.group(3).find(']') == -1): + # Split the size using space and arithmetic operators as delimiters. + # If any of the resulting tokens are not compile time constants then + # report the error. + tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', match.group(3)) + is_const = True + skip_next = False + for tok in tokens: + if skip_next: + skip_next = False + continue + + if Search(r'sizeof\(.+\)', tok): continue + if Search(r'arraysize\(\w+\)', tok): continue + + tok = tok.lstrip('(') + tok = tok.rstrip(')') + if not tok: continue + if Match(r'\d+', tok): continue + if Match(r'0[xX][0-9a-fA-F]+', tok): continue + if Match(r'k[A-Z0-9]\w*', tok): continue + if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue + if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue + # A catch all for tricky sizeof cases, including 'sizeof expression', + # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)' + # requires skipping the next token because we split on ' ' and '*'. + if tok.startswith('sizeof'): + skip_next = True + continue + is_const = False + break + if not is_const: + error(filename, linenum, 'runtime/arrays', 1, + 'Do not use variable-length arrays. Use an appropriately named ' + "('k' followed by CamelCase) compile-time constant for the size.") + + # Check for use of unnamed namespaces in header files. Registration + # macros are typically OK, so we allow use of "namespace {" on lines + # that end with backslashes. + if (IsHeaderExtension(file_extension) + and Search(r'\bnamespace\s*{', line) + and line[-1] != '\\'): + error(filename, linenum, 'build/namespaces_headers', 4, + 'Do not use unnamed namespaces in header files. See ' + 'https://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces' + ' for more information.') + + +def CheckGlobalStatic(filename, clean_lines, linenum, error): + """Check for unsafe global or static objects. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Match two lines at a time to support multiline declarations + if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line): + line += clean_lines.elided[linenum + 1].strip() + + # Check for people declaring static/global STL strings at the top level. + # This is dangerous because the C++ language does not guarantee that + # globals with constructors are initialized before the first access, and + # also because globals can be destroyed when some threads are still running. + # TODO(unknown): Generalize this to also find static unique_ptr instances. + # TODO(unknown): File bugs for clang-tidy to find these. + match = Match( + r'((?:|static +)(?:|const +))(?::*std::)?string( +const)? +' + r'([a-zA-Z0-9_:]+)\b(.*)', + line) + + # Remove false positives: + # - String pointers (as opposed to values). + # string *pointer + # const string *pointer + # string const *pointer + # string *const pointer + # + # - Functions and template specializations. + # string Function(... + # string Class::Method(... + # + # - Operators. These are matched separately because operator names + # cross non-word boundaries, and trying to match both operators + # and functions at the same time would decrease accuracy of + # matching identifiers. + # string Class::operator*() + if (match and + not Search(r'\bstring\b(\s+const)?\s*[\*\&]\s*(const\s+)?\w', line) and + not Search(r'\boperator\W', line) and + not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)*\s*\(([^"]|$)', match.group(4))): + if Search(r'\bconst\b', line): + error(filename, linenum, 'runtime/string', 4, + 'For a static/global string constant, use a C style string ' + 'instead: "%schar%s %s[]".' % + (match.group(1), match.group(2) or '', match.group(3))) + else: + error(filename, linenum, 'runtime/string', 4, + 'Static/global string variables are not permitted.') + + if (Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line) or + Search(r'\b([A-Za-z0-9_]*_)\(CHECK_NOTNULL\(\1\)\)', line)): + error(filename, linenum, 'runtime/init', 4, + 'You seem to be initializing a member variable with itself.') + + +def CheckPrintf(filename, clean_lines, linenum, error): + """Check for printf related issues. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # When snprintf is used, the second argument shouldn't be a literal. + match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line) + if match and match.group(2) != '0': + # If 2nd arg is zero, snprintf is used to calculate size. + error(filename, linenum, 'runtime/printf', 3, + 'If you can, use sizeof(%s) instead of %s as the 2nd arg ' + 'to snprintf.' % (match.group(1), match.group(2))) + + # Check if some verboten C functions are being used. + if Search(r'\bsprintf\s*\(', line): + error(filename, linenum, 'runtime/printf', 5, + 'Never use sprintf. Use snprintf instead.') + match = Search(r'\b(strcpy|strcat)\s*\(', line) + if match: + error(filename, linenum, 'runtime/printf', 4, + 'Almost always, snprintf is better than %s' % match.group(1)) + + +def IsDerivedFunction(clean_lines, linenum): + """Check if current line contains an inherited function. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + Returns: + True if current line contains a function with "override" + virt-specifier. + """ + # Scan back a few lines for start of current function + for i in xrange(linenum, max(-1, linenum - 10), -1): + match = Match(r'^([^()]*\w+)\(', clean_lines.elided[i]) + if match: + # Look for "override" after the matching closing parenthesis + line, _, closing_paren = CloseExpression( + clean_lines, i, len(match.group(1))) + return (closing_paren >= 0 and + Search(r'\boverride\b', line[closing_paren:])) + return False + + +def IsOutOfLineMethodDefinition(clean_lines, linenum): + """Check if current line contains an out-of-line method definition. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + Returns: + True if current line contains an out-of-line method definition. + """ + # Scan back a few lines for start of current function + for i in xrange(linenum, max(-1, linenum - 10), -1): + if Match(r'^([^()]*\w+)\(', clean_lines.elided[i]): + return Match(r'^[^()]*\w+::\w+\(', clean_lines.elided[i]) is not None + return False + + +def IsInitializerList(clean_lines, linenum): + """Check if current line is inside constructor initializer list. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + Returns: + True if current line appears to be inside constructor initializer + list, False otherwise. + """ + for i in xrange(linenum, 1, -1): + line = clean_lines.elided[i] + if i == linenum: + remove_function_body = Match(r'^(.*)\{\s*$', line) + if remove_function_body: + line = remove_function_body.group(1) + + if Search(r'\s:\s*\w+[({]', line): + # A lone colon tend to indicate the start of a constructor + # initializer list. It could also be a ternary operator, which + # also tend to appear in constructor initializer lists as + # opposed to parameter lists. + return True + if Search(r'\}\s*,\s*$', line): + # A closing brace followed by a comma is probably the end of a + # brace-initialized member in constructor initializer list. + return True + if Search(r'[{};]\s*$', line): + # Found one of the following: + # - A closing brace or semicolon, probably the end of the previous + # function. + # - An opening brace, probably the start of current class or namespace. + # + # Current line is probably not inside an initializer list since + # we saw one of those things without seeing the starting colon. + return False + + # Got to the beginning of the file without seeing the start of + # constructor initializer list. + return False + + +def CheckForNonConstReference(filename, clean_lines, linenum, + nesting_state, error): + """Check for non-const references. + + Separate from CheckLanguage since it scans backwards from current + line, instead of scanning forward. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + # Do nothing if there is no '&' on current line. + line = clean_lines.elided[linenum] + if '&' not in line: + return + + # If a function is inherited, current function doesn't have much of + # a choice, so any non-const references should not be blamed on + # derived function. + if IsDerivedFunction(clean_lines, linenum): + return + + # Don't warn on out-of-line method definitions, as we would warn on the + # in-line declaration, if it isn't marked with 'override'. + if IsOutOfLineMethodDefinition(clean_lines, linenum): + return + + # Long type names may be broken across multiple lines, usually in one + # of these forms: + # LongType + # ::LongTypeContinued &identifier + # LongType:: + # LongTypeContinued &identifier + # LongType< + # ...>::LongTypeContinued &identifier + # + # If we detected a type split across two lines, join the previous + # line to current line so that we can match const references + # accordingly. + # + # Note that this only scans back one line, since scanning back + # arbitrary number of lines would be expensive. If you have a type + # that spans more than 2 lines, please use a typedef. + if linenum > 1: + previous = None + if Match(r'\s*::(?:[\w<>]|::)+\s*&\s*\S', line): + # previous_line\n + ::current_line + previous = Search(r'\b((?:const\s*)?(?:[\w<>]|::)+[\w<>])\s*$', + clean_lines.elided[linenum - 1]) + elif Match(r'\s*[a-zA-Z_]([\w<>]|::)+\s*&\s*\S', line): + # previous_line::\n + current_line + previous = Search(r'\b((?:const\s*)?(?:[\w<>]|::)+::)\s*$', + clean_lines.elided[linenum - 1]) + if previous: + line = previous.group(1) + line.lstrip() + else: + # Check for templated parameter that is split across multiple lines + endpos = line.rfind('>') + if endpos > -1: + (_, startline, startpos) = ReverseCloseExpression( + clean_lines, linenum, endpos) + if startpos > -1 and startline < linenum: + # Found the matching < on an earlier line, collect all + # pieces up to current line. + line = '' + for i in xrange(startline, linenum + 1): + line += clean_lines.elided[i].strip() + + # Check for non-const references in function parameters. A single '&' may + # found in the following places: + # inside expression: binary & for bitwise AND + # inside expression: unary & for taking the address of something + # inside declarators: reference parameter + # We will exclude the first two cases by checking that we are not inside a + # function body, including one that was just introduced by a trailing '{'. + # TODO(unknown): Doesn't account for 'catch(Exception& e)' [rare]. + if (nesting_state.previous_stack_top and + not (isinstance(nesting_state.previous_stack_top, _ClassInfo) or + isinstance(nesting_state.previous_stack_top, _NamespaceInfo))): + # Not at toplevel, not within a class, and not within a namespace + return + + # Avoid initializer lists. We only need to scan back from the + # current line for something that starts with ':'. + # + # We don't need to check the current line, since the '&' would + # appear inside the second set of parentheses on the current line as + # opposed to the first set. + if linenum > 0: + for i in xrange(linenum - 1, max(0, linenum - 10), -1): + previous_line = clean_lines.elided[i] + if not Search(r'[),]\s*$', previous_line): + break + if Match(r'^\s*:\s+\S', previous_line): + return + + # Avoid preprocessors + if Search(r'\\\s*$', line): + return + + # Avoid constructor initializer lists + if IsInitializerList(clean_lines, linenum): + return + + # We allow non-const references in a few standard places, like functions + # called "swap()" or iostream operators like "<<" or ">>". Do not check + # those function parameters. + # + # We also accept & in static_assert, which looks like a function but + # it's actually a declaration expression. + allowed_functions = (r'(?:[sS]wap(?:<\w:+>)?|' + r'operator\s*[<>][<>]|' + r'static_assert|COMPILE_ASSERT' + r')\s*\(') + if Search(allowed_functions, line): + return + elif not Search(r'\S+\([^)]*$', line): + # Don't see an allowed function on this line. Actually we + # didn't see any function name on this line, so this is likely a + # multi-line parameter list. Try a bit harder to catch this case. + for i in xrange(2): + if (linenum > i and + Search(allowed_functions, clean_lines.elided[linenum - i - 1])): + return + + decls = ReplaceAll(r'{[^}]*}', ' ', line) # exclude function body + for parameter in re.findall(_RE_PATTERN_REF_PARAM, decls): + if (not Match(_RE_PATTERN_CONST_REF_PARAM, parameter) and + not Match(_RE_PATTERN_REF_STREAM_PARAM, parameter)): + error(filename, linenum, 'runtime/references', 2, + 'Is this a non-const reference? ' + 'If so, make const or use a pointer: ' + + ReplaceAll(' *<', '<', parameter)) + + +def CheckCasts(filename, clean_lines, linenum, error): + """Various cast related checks. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Check to see if they're using an conversion function cast. + # I just try to capture the most common basic types, though there are more. + # Parameterless conversion functions, such as bool(), are allowed as they are + # probably a member operator declaration or default constructor. + match = Search( + r'(\bnew\s+(?:const\s+)?|\S<\s*(?:const\s+)?)?\b' + r'(int|float|double|bool|char|int32|uint32|int64|uint64)' + r'(\([^)].*)', line) + expecting_function = ExpectingFunctionArgs(clean_lines, linenum) + if match and not expecting_function: + matched_type = match.group(2) + + # matched_new_or_template is used to silence two false positives: + # - New operators + # - Template arguments with function types + # + # For template arguments, we match on types immediately following + # an opening bracket without any spaces. This is a fast way to + # silence the common case where the function type is the first + # template argument. False negative with less-than comparison is + # avoided because those operators are usually followed by a space. + # + # function // bracket + no space = false positive + # value < double(42) // bracket + space = true positive + matched_new_or_template = match.group(1) + + # Avoid arrays by looking for brackets that come after the closing + # parenthesis. + if Match(r'\([^()]+\)\s*\[', match.group(3)): + return + + # Other things to ignore: + # - Function pointers + # - Casts to pointer types + # - Placement new + # - Alias declarations + matched_funcptr = match.group(3) + if (matched_new_or_template is None and + not (matched_funcptr and + (Match(r'\((?:[^() ]+::\s*\*\s*)?[^() ]+\)\s*\(', + matched_funcptr) or + matched_funcptr.startswith('(*)'))) and + not Match(r'\s*using\s+\S+\s*=\s*' + matched_type, line) and + not Search(r'new\(\S+\)\s*' + matched_type, line)): + error(filename, linenum, 'readability/casting', 4, + 'Using deprecated casting style. ' + 'Use static_cast<%s>(...) instead' % + matched_type) + + if not expecting_function: + CheckCStyleCast(filename, clean_lines, linenum, 'static_cast', + r'\((int|float|double|bool|char|u?int(16|32|64))\)', error) + + # This doesn't catch all cases. Consider (const char * const)"hello". + # + # (char *) "foo" should always be a const_cast (reinterpret_cast won't + # compile). + if CheckCStyleCast(filename, clean_lines, linenum, 'const_cast', + r'\((char\s?\*+\s?)\)\s*"', error): + pass + else: + # Check pointer casts for other than string constants + CheckCStyleCast(filename, clean_lines, linenum, 'reinterpret_cast', + r'\((\w+\s?\*+\s?)\)', error) + + # In addition, we look for people taking the address of a cast. This + # is dangerous -- casts can assign to temporaries, so the pointer doesn't + # point where you think. + # + # Some non-identifier character is required before the '&' for the + # expression to be recognized as a cast. These are casts: + # expression = &static_cast(temporary()); + # function(&(int*)(temporary())); + # + # This is not a cast: + # reference_type&(int* function_param); + match = Search( + r'(?:[^\w]&\(([^)*][^)]*)\)[\w(])|' + r'(?:[^\w]&(static|dynamic|down|reinterpret)_cast\b)', line) + if match: + # Try a better error message when the & is bound to something + # dereferenced by the casted pointer, as opposed to the casted + # pointer itself. + parenthesis_error = False + match = Match(r'^(.*&(?:static|dynamic|down|reinterpret)_cast\b)<', line) + if match: + _, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(1))) + if x1 >= 0 and clean_lines.elided[y1][x1] == '(': + _, y2, x2 = CloseExpression(clean_lines, y1, x1) + if x2 >= 0: + extended_line = clean_lines.elided[y2][x2:] + if y2 < clean_lines.NumLines() - 1: + extended_line += clean_lines.elided[y2 + 1] + if Match(r'\s*(?:->|\[)', extended_line): + parenthesis_error = True + + if parenthesis_error: + error(filename, linenum, 'readability/casting', 4, + ('Are you taking an address of something dereferenced ' + 'from a cast? Wrapping the dereferenced expression in ' + 'parentheses will make the binding more obvious')) + else: + error(filename, linenum, 'runtime/casting', 4, + ('Are you taking an address of a cast? ' + 'This is dangerous: could be a temp var. ' + 'Take the address before doing the cast, rather than after')) + + +def CheckCStyleCast(filename, clean_lines, linenum, cast_type, pattern, error): + """Checks for a C-style cast by looking for the pattern. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + cast_type: The string for the C++ cast to recommend. This is either + reinterpret_cast, static_cast, or const_cast, depending. + pattern: The regular expression used to find C-style casts. + error: The function to call with any errors found. + + Returns: + True if an error was emitted. + False otherwise. + """ + line = clean_lines.elided[linenum] + match = Search(pattern, line) + if not match: + return False + + # Exclude lines with keywords that tend to look like casts + context = line[0:match.start(1) - 1] + if Match(r'.*\b(?:sizeof|alignof|alignas|[_A-Z][_A-Z0-9]*)\s*$', context): + return False + + # Try expanding current context to see if we one level of + # parentheses inside a macro. + if linenum > 0: + for i in xrange(linenum - 1, max(0, linenum - 5), -1): + context = clean_lines.elided[i] + context + if Match(r'.*\b[_A-Z][_A-Z0-9]*\s*\((?:\([^()]*\)|[^()])*$', context): + return False + + # operator++(int) and operator--(int) + if context.endswith(' operator++') or context.endswith(' operator--'): + return False + + # A single unnamed argument for a function tends to look like old style cast. + # If we see those, don't issue warnings for deprecated casts. + remainder = line[match.end(0):] + if Match(r'^\s*(?:;|const\b|throw\b|final\b|override\b|[=>{),]|->)', + remainder): + return False + + # At this point, all that should be left is actual casts. + error(filename, linenum, 'readability/casting', 4, + 'Using C-style cast. Use %s<%s>(...) instead' % + (cast_type, match.group(1))) + + return True + + +def ExpectingFunctionArgs(clean_lines, linenum): + """Checks whether where function type arguments are expected. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + + Returns: + True if the line at 'linenum' is inside something that expects arguments + of function types. + """ + line = clean_lines.elided[linenum] + return (Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or + (linenum >= 2 and + (Match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\((?:\S+,)?\s*$', + clean_lines.elided[linenum - 1]) or + Match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\(\s*$', + clean_lines.elided[linenum - 2]) or + Search(r'\bstd::m?function\s*\<\s*$', + clean_lines.elided[linenum - 1])))) + + +_HEADERS_CONTAINING_TEMPLATES = ( + ('', ('deque',)), + ('', ('unary_function', 'binary_function', + 'plus', 'minus', 'multiplies', 'divides', 'modulus', + 'negate', + 'equal_to', 'not_equal_to', 'greater', 'less', + 'greater_equal', 'less_equal', + 'logical_and', 'logical_or', 'logical_not', + 'unary_negate', 'not1', 'binary_negate', 'not2', + 'bind1st', 'bind2nd', + 'pointer_to_unary_function', + 'pointer_to_binary_function', + 'ptr_fun', + 'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t', + 'mem_fun_ref_t', + 'const_mem_fun_t', 'const_mem_fun1_t', + 'const_mem_fun_ref_t', 'const_mem_fun1_ref_t', + 'mem_fun_ref', + )), + ('', ('numeric_limits',)), + ('', ('list',)), + ('', ('multimap',)), + ('', ('allocator', 'make_shared', 'make_unique', 'shared_ptr', + 'unique_ptr', 'weak_ptr')), + ('', ('queue', 'priority_queue',)), + ('', ('multiset',)), + ('', ('stack',)), + ('', ('char_traits', 'basic_string',)), + ('', ('tuple',)), + ('', ('unordered_map', 'unordered_multimap')), + ('', ('unordered_set', 'unordered_multiset')), + ('', ('pair',)), + ('', ('vector',)), + + # gcc extensions. + # Note: std::hash is their hash, ::hash is our hash + ('', ('hash_map', 'hash_multimap',)), + ('', ('hash_set', 'hash_multiset',)), + ('', ('slist',)), + ) + +_HEADERS_MAYBE_TEMPLATES = ( + ('', ('copy', 'max', 'min', 'min_element', 'sort', + 'transform', + )), + ('', ('forward', 'make_pair', 'move', 'swap')), + ) + +_RE_PATTERN_STRING = re.compile(r'\bstring\b') + +_re_pattern_headers_maybe_templates = [] +for _header, _templates in _HEADERS_MAYBE_TEMPLATES: + for _template in _templates: + # Match max(..., ...), max(..., ...), but not foo->max, foo.max or + # 'type::max()'. + _re_pattern_headers_maybe_templates.append( + (re.compile(r'[^>.]\b' + _template + r'(<.*?>)?\([^\)]'), + _template, + _header)) +# Match set, but not foo->set, foo.set +_re_pattern_headers_maybe_templates.append( + (re.compile(r'[^>.]\bset\s*\<'), + 'set<>', + '')) +# Match 'map var' and 'std::map(...)', but not 'map(...)'' +_re_pattern_headers_maybe_templates.append( + (re.compile(r'(std\b::\bmap\s*\<)|(^(std\b::\b)map\b\(\s*\<)'), + 'map<>', + '')) + +# Other scripts may reach in and modify this pattern. +_re_pattern_templates = [] +for _header, _templates in _HEADERS_CONTAINING_TEMPLATES: + for _template in _templates: + _re_pattern_templates.append( + (re.compile(r'(\<|\b)' + _template + r'\s*\<'), + _template + '<>', + _header)) + + +def FilesBelongToSameModule(filename_cc, filename_h): + """Check if these two filenames belong to the same module. + + The concept of a 'module' here is a as follows: + foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the + same 'module' if they are in the same directory. + some/path/public/xyzzy and some/path/internal/xyzzy are also considered + to belong to the same module here. + + If the filename_cc contains a longer path than the filename_h, for example, + '/absolute/path/to/base/sysinfo.cc', and this file would include + 'base/sysinfo.h', this function also produces the prefix needed to open the + header. This is used by the caller of this function to more robustly open the + header file. We don't have access to the real include paths in this context, + so we need this guesswork here. + + Known bugs: tools/base/bar.cc and base/bar.h belong to the same module + according to this implementation. Because of this, this function gives + some false positives. This should be sufficiently rare in practice. + + Args: + filename_cc: is the path for the source (e.g. .cc) file + filename_h: is the path for the header path + + Returns: + Tuple with a bool and a string: + bool: True if filename_cc and filename_h belong to the same module. + string: the additional prefix needed to open the header file. + """ + fileinfo_cc = FileInfo(filename_cc) + if not fileinfo_cc.Extension().lstrip('.') in GetNonHeaderExtensions(): + return (False, '') + + fileinfo_h = FileInfo(filename_h) + if not IsHeaderExtension(fileinfo_h.Extension().lstrip('.')): + return (False, '') + + filename_cc = filename_cc[:-(len(fileinfo_cc.Extension()))] + matched_test_suffix = Search(_TEST_FILE_SUFFIX, fileinfo_cc.BaseName()) + if matched_test_suffix: + filename_cc = filename_cc[:-len(matched_test_suffix.group(1))] + + filename_cc = filename_cc.replace('/public/', '/') + filename_cc = filename_cc.replace('/internal/', '/') + + filename_h = filename_h[:-(len(fileinfo_h.Extension()))] + if filename_h.endswith('-inl'): + filename_h = filename_h[:-len('-inl')] + filename_h = filename_h.replace('/public/', '/') + filename_h = filename_h.replace('/internal/', '/') + + files_belong_to_same_module = filename_cc.endswith(filename_h) + common_path = '' + if files_belong_to_same_module: + common_path = filename_cc[:-len(filename_h)] + return files_belong_to_same_module, common_path + + +def UpdateIncludeState(filename, include_dict, io=codecs): + """Fill up the include_dict with new includes found from the file. + + Args: + filename: the name of the header to read. + include_dict: a dictionary in which the headers are inserted. + io: The io factory to use to read the file. Provided for testability. + + Returns: + True if a header was successfully added. False otherwise. + """ + headerfile = None + try: + with io.open(filename, 'r', 'utf8', 'replace') as headerfile: + linenum = 0 + for line in headerfile: + linenum += 1 + clean_line = CleanseComments(line) + match = _RE_PATTERN_INCLUDE.search(clean_line) + if match: + include = match.group(2) + include_dict.setdefault(include, linenum) + return True + except IOError: + return False + + + +def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error, + io=codecs): + """Reports for missing stl includes. + + This function will output warnings to make sure you are including the headers + necessary for the stl containers and functions that you use. We only give one + reason to include a header. For example, if you use both equal_to<> and + less<> in a .h file, only one (the latter in the file) of these will be + reported as a reason to include the . + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + include_state: An _IncludeState instance. + error: The function to call with any errors found. + io: The IO factory to use to read the header file. Provided for unittest + injection. + """ + required = {} # A map of header name to linenumber and the template entity. + # Example of required: { '': (1219, 'less<>') } + + for linenum in xrange(clean_lines.NumLines()): + line = clean_lines.elided[linenum] + if not line or line[0] == '#': + continue + + # String is special -- it is a non-templatized type in STL. + matched = _RE_PATTERN_STRING.search(line) + if matched: + # Don't warn about strings in non-STL namespaces: + # (We check only the first match per line; good enough.) + prefix = line[:matched.start()] + if prefix.endswith('std::') or not prefix.endswith('::'): + required[''] = (linenum, 'string') + + for pattern, template, header in _re_pattern_headers_maybe_templates: + if pattern.search(line): + required[header] = (linenum, template) + + # The following function is just a speed up, no semantics are changed. + if not '<' in line: # Reduces the cpu time usage by skipping lines. + continue + + for pattern, template, header in _re_pattern_templates: + matched = pattern.search(line) + if matched: + # Don't warn about IWYU in non-STL namespaces: + # (We check only the first match per line; good enough.) + prefix = line[:matched.start()] + if prefix.endswith('std::') or not prefix.endswith('::'): + required[header] = (linenum, template) + + # The policy is that if you #include something in foo.h you don't need to + # include it again in foo.cc. Here, we will look at possible includes. + # Let's flatten the include_state include_list and copy it into a dictionary. + include_dict = dict([item for sublist in include_state.include_list + for item in sublist]) + + # Did we find the header for this file (if any) and successfully load it? + header_found = False + + # Use the absolute path so that matching works properly. + abs_filename = FileInfo(filename).FullName() + + # For Emacs's flymake. + # If cpplint is invoked from Emacs's flymake, a temporary file is generated + # by flymake and that file name might end with '_flymake.cc'. In that case, + # restore original file name here so that the corresponding header file can be + # found. + # e.g. If the file name is 'foo_flymake.cc', we should search for 'foo.h' + # instead of 'foo_flymake.h' + abs_filename = re.sub(r'_flymake\.cc$', '.cc', abs_filename) + + # include_dict is modified during iteration, so we iterate over a copy of + # the keys. + header_keys = list(include_dict.keys()) + for header in header_keys: + (same_module, common_path) = FilesBelongToSameModule(abs_filename, header) + fullpath = common_path + header + if same_module and UpdateIncludeState(fullpath, include_dict, io): + header_found = True + + # If we can't find the header file for a .cc, assume it's because we don't + # know where to look. In that case we'll give up as we're not sure they + # didn't include it in the .h file. + # TODO(unknown): Do a better job of finding .h files so we are confident that + # not having the .h file means there isn't one. + if not header_found: + for extension in GetNonHeaderExtensions(): + if filename.endswith('.' + extension): + return + + # All the lines have been processed, report the errors found. + for required_header_unstripped in sorted(required, key=required.__getitem__): + template = required[required_header_unstripped][1] + if required_header_unstripped.strip('<>"') not in include_dict: + error(filename, required[required_header_unstripped][0], + 'build/include_what_you_use', 4, + 'Add #include ' + required_header_unstripped + ' for ' + template) + + +_RE_PATTERN_EXPLICIT_MAKEPAIR = re.compile(r'\bmake_pair\s*<') + + +def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error): + """Check that make_pair's template arguments are deduced. + + G++ 4.6 in C++11 mode fails badly if make_pair's template arguments are + specified explicitly, and such use isn't intended in any case. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + match = _RE_PATTERN_EXPLICIT_MAKEPAIR.search(line) + if match: + error(filename, linenum, 'build/explicit_make_pair', + 4, # 4 = high confidence + 'For C++11-compatibility, omit template arguments from make_pair' + ' OR use pair directly OR if appropriate, construct a pair directly') + + +def CheckRedundantVirtual(filename, clean_lines, linenum, error): + """Check if line contains a redundant "virtual" function-specifier. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + # Look for "virtual" on current line. + line = clean_lines.elided[linenum] + virtual = Match(r'^(.*)(\bvirtual\b)(.*)$', line) + if not virtual: return + + # Ignore "virtual" keywords that are near access-specifiers. These + # are only used in class base-specifier and do not apply to member + # functions. + if (Search(r'\b(public|protected|private)\s+$', virtual.group(1)) or + Match(r'^\s+(public|protected|private)\b', virtual.group(3))): + return + + # Ignore the "virtual" keyword from virtual base classes. Usually + # there is a column on the same line in these cases (virtual base + # classes are rare in google3 because multiple inheritance is rare). + if Match(r'^.*[^:]:[^:].*$', line): return + + # Look for the next opening parenthesis. This is the start of the + # parameter list (possibly on the next line shortly after virtual). + # TODO(unknown): doesn't work if there are virtual functions with + # decltype() or other things that use parentheses, but csearch suggests + # that this is rare. + end_col = -1 + end_line = -1 + start_col = len(virtual.group(2)) + for start_line in xrange(linenum, min(linenum + 3, clean_lines.NumLines())): + line = clean_lines.elided[start_line][start_col:] + parameter_list = Match(r'^([^(]*)\(', line) + if parameter_list: + # Match parentheses to find the end of the parameter list + (_, end_line, end_col) = CloseExpression( + clean_lines, start_line, start_col + len(parameter_list.group(1))) + break + start_col = 0 + + if end_col < 0: + return # Couldn't find end of parameter list, give up + + # Look for "override" or "final" after the parameter list + # (possibly on the next few lines). + for i in xrange(end_line, min(end_line + 3, clean_lines.NumLines())): + line = clean_lines.elided[i][end_col:] + match = Search(r'\b(override|final)\b', line) + if match: + error(filename, linenum, 'readability/inheritance', 4, + ('"virtual" is redundant since function is ' + 'already declared as "%s"' % match.group(1))) + + # Set end_col to check whole lines after we are done with the + # first line. + end_col = 0 + if Search(r'[^\w]\s*$', line): + break + + +def CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error): + """Check if line contains a redundant "override" or "final" virt-specifier. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + # Look for closing parenthesis nearby. We need one to confirm where + # the declarator ends and where the virt-specifier starts to avoid + # false positives. + line = clean_lines.elided[linenum] + declarator_end = line.rfind(')') + if declarator_end >= 0: + fragment = line[declarator_end:] + else: + if linenum > 1 and clean_lines.elided[linenum - 1].rfind(')') >= 0: + fragment = line + else: + return + + # Check that at most one of "override" or "final" is present, not both + if Search(r'\boverride\b', fragment) and Search(r'\bfinal\b', fragment): + error(filename, linenum, 'readability/inheritance', 4, + ('"override" is redundant since function is ' + 'already declared as "final"')) + + + + +# Returns true if we are at a new block, and it is directly +# inside of a namespace. +def IsBlockInNameSpace(nesting_state, is_forward_declaration): + """Checks that the new block is directly in a namespace. + + Args: + nesting_state: The _NestingState object that contains info about our state. + is_forward_declaration: If the class is a forward declared class. + Returns: + Whether or not the new block is directly in a namespace. + """ + if is_forward_declaration: + return len(nesting_state.stack) >= 1 and ( + isinstance(nesting_state.stack[-1], _NamespaceInfo)) + + + return (len(nesting_state.stack) > 1 and + nesting_state.stack[-1].check_namespace_indentation and + isinstance(nesting_state.stack[-2], _NamespaceInfo)) + + +def ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item, + raw_lines_no_comments, linenum): + """This method determines if we should apply our namespace indentation check. + + Args: + nesting_state: The current nesting state. + is_namespace_indent_item: If we just put a new class on the stack, True. + If the top of the stack is not a class, or we did not recently + add the class, False. + raw_lines_no_comments: The lines without the comments. + linenum: The current line number we are processing. + + Returns: + True if we should apply our namespace indentation check. Currently, it + only works for classes and namespaces inside of a namespace. + """ + + is_forward_declaration = IsForwardClassDeclaration(raw_lines_no_comments, + linenum) + + if not (is_namespace_indent_item or is_forward_declaration): + return False + + # If we are in a macro, we do not want to check the namespace indentation. + if IsMacroDefinition(raw_lines_no_comments, linenum): + return False + + return IsBlockInNameSpace(nesting_state, is_forward_declaration) + + +# Call this method if the line is directly inside of a namespace. +# If the line above is blank (excluding comments) or the start of +# an inner namespace, it cannot be indented. +def CheckItemIndentationInNamespace(filename, raw_lines_no_comments, linenum, + error): + line = raw_lines_no_comments[linenum] + if Match(r'^\s+', line): + error(filename, linenum, 'runtime/indentation_namespace', 4, + 'Do not indent within a namespace') + + +def ProcessLine(filename, file_extension, clean_lines, line, + include_state, function_state, nesting_state, error, + extra_check_functions=None): + """Processes a single line in the file. + + Args: + filename: Filename of the file that is being processed. + file_extension: The extension (dot not included) of the file. + clean_lines: An array of strings, each representing a line of the file, + with comments stripped. + line: Number of line being processed. + include_state: An _IncludeState instance in which the headers are inserted. + function_state: A _FunctionState instance which counts function lines, etc. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: A callable to which errors are reported, which takes 4 arguments: + filename, line number, error level, and message + extra_check_functions: An array of additional check functions that will be + run on each source line. Each function takes 4 + arguments: filename, clean_lines, line, error + """ + raw_lines = clean_lines.raw_lines + ParseNolintSuppressions(filename, raw_lines[line], line, error) + nesting_state.Update(filename, clean_lines, line, error) + CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line, + error) + if nesting_state.InAsmBlock(): return + CheckForFunctionLengths(filename, clean_lines, line, function_state, error) + CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error) + CheckStyle(filename, clean_lines, line, file_extension, nesting_state, error) + CheckLanguage(filename, clean_lines, line, file_extension, include_state, + nesting_state, error) + CheckForNonConstReference(filename, clean_lines, line, nesting_state, error) + CheckForNonStandardConstructs(filename, clean_lines, line, + nesting_state, error) + CheckVlogArguments(filename, clean_lines, line, error) + CheckPosixThreading(filename, clean_lines, line, error) + CheckInvalidIncrement(filename, clean_lines, line, error) + CheckMakePairUsesDeduction(filename, clean_lines, line, error) + CheckRedundantVirtual(filename, clean_lines, line, error) + CheckRedundantOverrideOrFinal(filename, clean_lines, line, error) + if extra_check_functions: + for check_fn in extra_check_functions: + check_fn(filename, clean_lines, line, error) + +def FlagCxx11Features(filename, clean_lines, linenum, error): + """Flag those c++11 features that we only allow in certain places. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + include = Match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line) + + # Flag unapproved C++ TR1 headers. + if include and include.group(1).startswith('tr1/'): + error(filename, linenum, 'build/c++tr1', 5, + ('C++ TR1 headers such as <%s> are unapproved.') % include.group(1)) + + # Flag unapproved C++11 headers. + if include and include.group(1) in ('cfenv', + 'condition_variable', + 'fenv.h', + 'future', + 'mutex', + 'thread', + 'chrono', + 'ratio', + 'regex', + 'system_error', + ): + error(filename, linenum, 'build/c++11', 5, + ('<%s> is an unapproved C++11 header.') % include.group(1)) + + # The only place where we need to worry about C++11 keywords and library + # features in preprocessor directives is in macro definitions. + if Match(r'\s*#', line) and not Match(r'\s*#\s*define\b', line): return + + # These are classes and free functions. The classes are always + # mentioned as std::*, but we only catch the free functions if + # they're not found by ADL. They're alphabetical by header. + for top_name in ( + # type_traits + 'alignment_of', + 'aligned_union', + ): + if Search(r'\bstd::%s\b' % top_name, line): + error(filename, linenum, 'build/c++11', 5, + ('std::%s is an unapproved C++11 class or function. Send c-style ' + 'an example of where it would make your code more readable, and ' + 'they may let you use it.') % top_name) + + +def FlagCxx14Features(filename, clean_lines, linenum, error): + """Flag those C++14 features that we restrict. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + include = Match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line) + + # Flag unapproved C++14 headers. + if include and include.group(1) in ('scoped_allocator', 'shared_mutex'): + error(filename, linenum, 'build/c++14', 5, + ('<%s> is an unapproved C++14 header.') % include.group(1)) + + +def ProcessFileData(filename, file_extension, lines, error, + extra_check_functions=None): + """Performs lint checks and reports any errors to the given error function. + + Args: + filename: Filename of the file that is being processed. + file_extension: The extension (dot not included) of the file. + lines: An array of strings, each representing a line of the file, with the + last element being empty if the file is terminated with a newline. + error: A callable to which errors are reported, which takes 4 arguments: + filename, line number, error level, and message + extra_check_functions: An array of additional check functions that will be + run on each source line. Each function takes 4 + arguments: filename, clean_lines, line, error + """ + lines = (['// marker so line numbers and indices both start at 1'] + lines + + ['// marker so line numbers end in a known way']) + + include_state = _IncludeState() + function_state = _FunctionState() + nesting_state = NestingState() + + ResetNolintSuppressions() + + CheckForCopyright(filename, lines, error) + ProcessGlobalSuppresions(lines) + RemoveMultiLineComments(filename, lines, error) + clean_lines = CleansedLines(lines) + + if IsHeaderExtension(file_extension): + CheckForHeaderGuard(filename, clean_lines, error) + + for line in xrange(clean_lines.NumLines()): + ProcessLine(filename, file_extension, clean_lines, line, + include_state, function_state, nesting_state, error, + extra_check_functions) + FlagCxx11Features(filename, clean_lines, line, error) + nesting_state.CheckCompletedBlocks(filename, error) + + CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error) + + # Check that the .cc file has included its header if it exists. + if _IsSourceExtension(file_extension): + CheckHeaderFileIncluded(filename, include_state, error) + + # We check here rather than inside ProcessLine so that we see raw + # lines rather than "cleaned" lines. + CheckForBadCharacters(filename, lines, error) + + CheckForNewlineAtEOF(filename, lines, error) + +def ProcessConfigOverrides(filename): + """ Loads the configuration files and processes the config overrides. + + Args: + filename: The name of the file being processed by the linter. + + Returns: + False if the current |filename| should not be processed further. + """ + + abs_filename = os.path.abspath(filename) + cfg_filters = [] + keep_looking = True + while keep_looking: + abs_path, base_name = os.path.split(abs_filename) + if not base_name: + break # Reached the root directory. + + cfg_file = os.path.join(abs_path, "CPPLINT.cfg") + abs_filename = abs_path + if not os.path.isfile(cfg_file): + continue + + try: + with open(cfg_file) as file_handle: + for line in file_handle: + line, _, _ = line.partition('#') # Remove comments. + if not line.strip(): + continue + + name, _, val = line.partition('=') + name = name.strip() + val = val.strip() + if name == 'set noparent': + keep_looking = False + elif name == 'filter': + cfg_filters.append(val) + elif name == 'exclude_files': + # When matching exclude_files pattern, use the base_name of + # the current file name or the directory name we are processing. + # For example, if we are checking for lint errors in /foo/bar/baz.cc + # and we found the .cfg file at /foo/CPPLINT.cfg, then the config + # file's "exclude_files" filter is meant to be checked against "bar" + # and not "baz" nor "bar/baz.cc". + if base_name: + pattern = re.compile(val) + if pattern.match(base_name): + if _cpplint_state.quiet: + # Suppress "Ignoring file" warning when using --quiet. + return False + _cpplint_state.PrintInfo('Ignoring "%s": file excluded by "%s". ' + 'File path component "%s" matches ' + 'pattern "%s"\n' % + (filename, cfg_file, base_name, val)) + return False + elif name == 'linelength': + global _line_length + try: + _line_length = int(val) + except ValueError: + _cpplint_state.PrintError('Line length must be numeric.') + elif name == 'extensions': + ProcessExtensionsOption(val) + elif name == 'root': + global _root + # root directories are specified relative to CPPLINT.cfg dir. + _root = os.path.join(os.path.dirname(cfg_file), val) + elif name == 'headers': + ProcessHppHeadersOption(val) + elif name == 'includeorder': + ProcessIncludeOrderOption(val) + else: + _cpplint_state.PrintError( + 'Invalid configuration option (%s) in file %s\n' % + (name, cfg_file)) + + except IOError: + _cpplint_state.PrintError( + "Skipping config file '%s': Can't open for reading\n" % cfg_file) + keep_looking = False + + # Apply all the accumulated filters in reverse order (top-level directory + # config options having the least priority). + for cfg_filter in reversed(cfg_filters): + _AddFilters(cfg_filter) + + return True + + +def ProcessFile(filename, vlevel, extra_check_functions=None): + """Does google-lint on a single file. + + Args: + filename: The name of the file to parse. + + vlevel: The level of errors to report. Every error of confidence + >= verbose_level will be reported. 0 is a good default. + + extra_check_functions: An array of additional check functions that will be + run on each source line. Each function takes 4 + arguments: filename, clean_lines, line, error + """ + + _SetVerboseLevel(vlevel) + _BackupFilters() + old_errors = _cpplint_state.error_count + + if not ProcessConfigOverrides(filename): + _RestoreFilters() + return + + lf_lines = [] + crlf_lines = [] + try: + # Support the UNIX convention of using "-" for stdin. Note that + # we are not opening the file with universal newline support + # (which codecs doesn't support anyway), so the resulting lines do + # contain trailing '\r' characters if we are reading a file that + # has CRLF endings. + # If after the split a trailing '\r' is present, it is removed + # below. + if filename == '-': + lines = codecs.StreamReaderWriter(sys.stdin, + codecs.getreader('utf8'), + codecs.getwriter('utf8'), + 'replace').read().split('\n') + else: + with codecs.open(filename, 'r', 'utf8', 'replace') as target_file: + lines = target_file.read().split('\n') + + # Remove trailing '\r'. + # The -1 accounts for the extra trailing blank line we get from split() + for linenum in range(len(lines) - 1): + if lines[linenum].endswith('\r'): + lines[linenum] = lines[linenum].rstrip('\r') + crlf_lines.append(linenum + 1) + else: + lf_lines.append(linenum + 1) + + except IOError: + _cpplint_state.PrintError( + "Skipping input '%s': Can't open for reading\n" % filename) + _RestoreFilters() + return + + # Note, if no dot is found, this will give the entire filename as the ext. + file_extension = filename[filename.rfind('.') + 1:] + + # When reading from stdin, the extension is unknown, so no cpplint tests + # should rely on the extension. + if filename != '-' and file_extension not in GetAllExtensions(): + _cpplint_state.PrintError('Ignoring %s; not a valid file name ' + '(%s)\n' % (filename, ', '.join(GetAllExtensions()))) + else: + ProcessFileData(filename, file_extension, lines, Error, + extra_check_functions) + + # If end-of-line sequences are a mix of LF and CR-LF, issue + # warnings on the lines with CR. + # + # Don't issue any warnings if all lines are uniformly LF or CR-LF, + # since critique can handle these just fine, and the style guide + # doesn't dictate a particular end of line sequence. + # + # We can't depend on os.linesep to determine what the desired + # end-of-line sequence should be, since that will return the + # server-side end-of-line sequence. + if lf_lines and crlf_lines: + # Warn on every line with CR. An alternative approach might be to + # check whether the file is mostly CRLF or just LF, and warn on the + # minority, we bias toward LF here since most tools prefer LF. + for linenum in crlf_lines: + Error(filename, linenum, 'whitespace/newline', 1, + 'Unexpected \\r (^M) found; better to use only \\n') + + # Suppress printing anything if --quiet was passed unless the error + # count has increased after processing this file. + if not _cpplint_state.quiet or old_errors != _cpplint_state.error_count: + _cpplint_state.PrintInfo('Done processing %s\n' % filename) + _RestoreFilters() + + +def PrintUsage(message): + """Prints a brief usage string and exits, optionally with an error message. + + Args: + message: The optional error message. + """ + sys.stderr.write(_USAGE % (list(GetAllExtensions()), + ','.join(list(GetAllExtensions())), + GetHeaderExtensions(), + ','.join(GetHeaderExtensions()))) + + if message: + sys.exit('\nFATAL ERROR: ' + message) + else: + sys.exit(0) + +def PrintVersion(): + sys.stdout.write('Cpplint fork (https://github.com/cpplint/cpplint)\n') + sys.stdout.write('cpplint ' + __VERSION__ + '\n') + sys.stdout.write('Python ' + sys.version + '\n') + sys.exit(0) + +def PrintCategories(): + """Prints a list of all the error-categories used by error messages. + + These are the categories used to filter messages via --filter. + """ + sys.stderr.write(''.join(' %s\n' % cat for cat in _ERROR_CATEGORIES)) + sys.exit(0) + + +def ParseArguments(args): + """Parses the command line arguments. + + This may set the output format and verbosity level as side-effects. + + Args: + args: The command line arguments: + + Returns: + The list of filenames to lint. + """ + try: + (opts, filenames) = getopt.getopt(args, '', ['help', 'output=', 'verbose=', + 'v=', + 'version', + 'counting=', + 'filter=', + 'root=', + 'repository=', + 'linelength=', + 'extensions=', + 'exclude=', + 'recursive', + 'headers=', + 'includeorder=', + 'quiet']) + except getopt.GetoptError: + PrintUsage('Invalid arguments.') + + verbosity = _VerboseLevel() + output_format = _OutputFormat() + filters = '' + quiet = _Quiet() + counting_style = '' + recursive = False + + for (opt, val) in opts: + if opt == '--help': + PrintUsage(None) + if opt == '--version': + PrintVersion() + elif opt == '--output': + if val not in ('emacs', 'vs7', 'eclipse', 'junit'): + PrintUsage('The only allowed output formats are emacs, vs7, eclipse ' + 'and junit.') + output_format = val + elif opt == '--quiet': + quiet = True + elif opt == '--verbose' or opt == '--v': + verbosity = int(val) + elif opt == '--filter': + filters = val + if not filters: + PrintCategories() + elif opt == '--counting': + if val not in ('total', 'toplevel', 'detailed'): + PrintUsage('Valid counting options are total, toplevel, and detailed') + counting_style = val + elif opt == '--root': + global _root + _root = val + elif opt == '--repository': + global _repository + _repository = val + elif opt == '--linelength': + global _line_length + try: + _line_length = int(val) + except ValueError: + PrintUsage('Line length must be digits.') + elif opt == '--exclude': + global _excludes + if not _excludes: + _excludes = set() + _excludes.update(glob.glob(val)) + elif opt == '--extensions': + ProcessExtensionsOption(val) + elif opt == '--headers': + ProcessHppHeadersOption(val) + elif opt == '--recursive': + recursive = True + elif opt == '--includeorder': + ProcessIncludeOrderOption(val) + + if not filenames: + PrintUsage('No files were specified.') + + if recursive: + filenames = _ExpandDirectories(filenames) + + if _excludes: + filenames = _FilterExcludedFiles(filenames) + + _SetOutputFormat(output_format) + _SetQuiet(quiet) + _SetVerboseLevel(verbosity) + _SetFilters(filters) + _SetCountingStyle(counting_style) + + filenames.sort() + return filenames + +def _ExpandDirectories(filenames): + """Searches a list of filenames and replaces directories in the list with + all files descending from those directories. Files with extensions not in + the valid extensions list are excluded. + + Args: + filenames: A list of files or directories + + Returns: + A list of all files that are members of filenames or descended from a + directory in filenames + """ + expanded = set() + for filename in filenames: + if not os.path.isdir(filename): + expanded.add(filename) + continue + + for root, _, files in os.walk(filename): + for loopfile in files: + fullname = os.path.join(root, loopfile) + if fullname.startswith('.' + os.path.sep): + fullname = fullname[len('.' + os.path.sep):] + expanded.add(fullname) + + filtered = [] + for filename in expanded: + if os.path.splitext(filename)[1][1:] in GetAllExtensions(): + filtered.append(filename) + return filtered + +def _FilterExcludedFiles(fnames): + """Filters out files listed in the --exclude command line switch. File paths + in the switch are evaluated relative to the current working directory + """ + exclude_paths = [os.path.abspath(f) for f in _excludes] + # because globbing does not work recursively, exclude all subpath of all excluded entries + return [f for f in fnames + if not any(e for e in exclude_paths + if _IsParentOrSame(e, os.path.abspath(f)))] + +def _IsParentOrSame(parent, child): + """Return true if child is subdirectory of parent. + Assumes both paths are absolute and don't contain symlinks. + """ + parent = os.path.normpath(parent) + child = os.path.normpath(child) + if parent == child: + return True + + prefix = os.path.commonprefix([parent, child]) + if prefix != parent: + return False + # Note: os.path.commonprefix operates on character basis, so + # take extra care of situations like '/foo/ba' and '/foo/bar/baz' + child_suffix = child[len(prefix):] + child_suffix = child_suffix.lstrip(os.sep) + return child == os.path.join(prefix, child_suffix) + +def main(): + filenames = ParseArguments(sys.argv[1:]) + backup_err = sys.stderr + try: + # Change stderr to write with replacement characters so we don't die + # if we try to print something containing non-ASCII characters. + sys.stderr = codecs.StreamReader(sys.stderr, 'replace') + + _cpplint_state.ResetErrorCounts() + for filename in filenames: + ProcessFile(filename, _cpplint_state.verbose_level) + # If --quiet is passed, suppress printing error count unless there are errors. + if not _cpplint_state.quiet or _cpplint_state.error_count > 0: + _cpplint_state.PrintErrorCounts() + + if _cpplint_state.output_format == 'junit': + sys.stderr.write(_cpplint_state.FormatJUnitXML()) + + finally: + sys.stderr = backup_err + + sys.exit(_cpplint_state.error_count > 0) + + +if __name__ == '__main__': + main() diff --git a/tools/image.mk b/tools/image.mk new file mode 100644 index 0000000..b1b4234 --- /dev/null +++ b/tools/image.mk @@ -0,0 +1,108 @@ +# Generates a bootable ISO image that can be transferred to external media, such as CDs or USB sticks. +# This will install, in addition to your kernel, the bootloader GRUB (https://www.gnu.org/software/grub/). +# +# The target 'gemu-iso' is used to test the image generated with 'iso'. +# +# Assuming that a USB mass-storage devices is connected as, for instance /dev/sdc, the target 'usb-sdc' +# can be used to make your device bootable (requires root access, substitute sdc with the matching device). +# Alternatively, you can burn the .iso file directly to CD. + +DD = dd +XORRISO = xorriso +MKISO = grub-mkrescue + +ISODIR = $(BUILDDIR)-iso +ISOGRUBCFG = boot/grub/grub.cfg +ISOKERNEL = boot/kernel +ISOINITRD = initrd +GRUBTITLE = $(shell id -un)s $(PROJECT) +GRUBTIMEOUT = 2 +GRUBBIN ?= /usr/lib/grub/i386-pc + + +# Default ISO target +iso: $(ISOFILE) + + +# Create Grub config +$(ISODIR)/$(ISOGRUBCFG): + @echo "GEN $@" + @mkdir -p $(dir $@) + @$(echo) "set timeout=$(GRUBTIMEOUT)\nset default=0\n\nmenuentry \"$(GRUBTITLE)\" {\n\tmultiboot /$(ISOKERNEL)\n\tmodule /$(ISOINITRD)\n\tboot\n}" > $@ + + +# Strip debug symbols from kernel binary +$(ISODIR)/$(ISOKERNEL): all + @echo "STRIP $@" + @mkdir -p $(dir $@) + $(VERBOSE) $(STRIP) --strip-debug --strip-unneeded -p -o $@ $(KERNEL) + + +# copy inital ramdisk +$(ISODIR)/$(ISOINITRD): all + @echo "CPY $@" + @mkdir -p $(dir $@) + @if [ -s $(INITRD) ] ; then cp -a $(INITRD) $@ ; else touch $@ ; fi + + +# Pack to ISO +$(ISOFILE): $(ISODIR)/$(ISOKERNEL) $(ISODIR)/$(ISOINITRD) $(ISODIR)/$(ISOGRUBCFG) + @echo "ISO $@" + @which $(XORRISO) >/dev/null || echo "Xorriso cannot be found - if building the ISO fails, this may be the reason!" >&2 + $(VERBOSE) $(MKISO) -d $(GRUBBIN) -o $@ $(ISODIR) + + +# Run ISO in QEMU/KVM +%-iso: $(ISOFILE) + @${MAKE} -s QEMUKERNEL="-cdrom $<" $* + + +# Copy ISO to USB device +usb: $(ISOFILE) +ifeq (,$(USBDEV)) + @echo "The environment variable USBDEV must contain the path to the USB mass-storage device:" >&2 + @lsblk -o TYPE,KNAME,SIZE,MODEL -a -p | grep "^disk" | cut -b 6- + @exit 1 +else + $(VERBOSE) $(DD) if=$< of=$(USBDEV) bs=4M status=progress && sync +endif + + +# Shorthand to copy ISO to a specific USB device +usb-%: + @$(MAKE) USBDEV=/dev/$* usb + + +# Burn ISO to CD +cd: $(ISOFILE) +ifeq (,$(CDRWDEV)) + @echo "The environment variable CDRWDEV must contain the path to the CD/DVD writer" >&2 + @exit 1 +else + $(VERBOSE) $(XORRISO) -as cdrecord -v dev=$(CDRWDEV) -dao $< +endif + + +# Shorthand to nurn ISO to specific CD device +cd-%: + @$(MAKE) CDRWDEV=/dev/$* cd + + +# The standard target 'clean' removes the whole generated system, the object files, and the dependency files. +clean:: + @echo "RM $(ISODIR)" + $(VERBOSE) rm -rf "$(ISODIR)" "$(ISODIR)$(OPTTAG)" "$(ISODIR)$(NOOPTTAG)" "$(ISODIR)$(DBGTAG)" "$(ISODIR)$(VERBOSETAG)" + + +# Documentation +help:: + @$(echo) "Bootable Images\n" \ + " \e[3miso\e[0m Generates a bootable system image (File: $(ISOFILE))\n\n" \ + " \e[3m*-iso\e[0m Simulate the system by booting from the virtual CD drive. (e.g. qemu-iso)\n\n" \ + " \e[3musb\e[0m Generates a bootable USB mass-storage device; the environment\n" \ + " variable \e[4mUSBDEV\e[0m should point to the USB device\n\n" \ + " \e[3mcd\e[0m Generates a bootable CD; the environment variable \e[4mCDRWDEV\e[0m\n" \ + " should point to the CD writer\n\n" + +# Phony targets +.PHONY: iso cd usb help diff --git a/tools/linter.mk b/tools/linter.mk new file mode 100644 index 0000000..98fda70 --- /dev/null +++ b/tools/linter.mk @@ -0,0 +1,34 @@ +# Perform static code checks + +TIDY ?= clang-tidy +CPPLINT ?= /usr/bin/env python "$(CURRENT_DIR)/cpplint.py" + + +# Check sources with Clang Tidy +tidy:: +ifeq (,$(CC_SOURCES)) + @echo "(nothing to tidy)" +else + $(VERBOSE) $(TIDY) $(filter-out utils/png.cc,$(CC_SOURCES)) -- $(CXXFLAGS_ARCH) $(CXXFLAGS_DEFAULT) $(CXXFLAGS_OPT) +endif + + +# Check sources with cpplint +lint:: + @if $(CPPLINT) --quiet --recursive . ; then \ + echo "Congratuations, coding style obeyed!" ; \ + else \ + echo "Coding style violated -- see CPPLINT.cfg for details" ; \ + exit 1 ; \ + fi + + +# Documentation +help:: + @$(echo) "Static Analysis and Linter\n" \ + " \e[3mlint\e[0m Checks the coding style using \e[4mCPPLINT\e[0m\n\n" \ + " \e[3mtidy\e[0m Uses \e[4mClang Tidy\e[0m for a static code analysis\n\n" + + +# Phony targets +.PHONY: tidy lint help diff --git a/tools/qemu.mk b/tools/qemu.mk new file mode 100644 index 0000000..08cb874 --- /dev/null +++ b/tools/qemu.mk @@ -0,0 +1,114 @@ +# Targets for running and debugging in Qemu/KVM + +QEMUCPUS ?= 4 +INITRD ?= /dev/null + +# Switch to curses if no graphical output is available +ifeq ($(DISPLAY),) + export QEMUDISPLAY ?= curses +else +# Macos display + ifeq ($(shell uname),Darwin) + export QEMUDISPLAY ?= cocoa + else + export QEMUDISPLAY ?= gtk + endif +endif + +export QEMUEXTRAFLAGS ?= + +# Architecture Specific flags +QEMUFLAGS += -k en-us -machine pcspk-audiodev=pa -d guest_errors -m 2048 +# Macos sound +ifeq ($(shell uname),Darwin) + QEMUFLAGS += -audiodev coreaudio,id=pa +else + QEMUFLAGS += -audiodev pa,id=pa +endif +DBGKERNEL ?= $(KERNEL64) +DBGARCH ?= i386:x86-64 +QEMU ?= qemu-system-x86_64 +QEMUKERNEL ?= -kernel $(KERNEL) -initrd $(INITRD) +KVMFLAGS = -enable-kvm -cpu host +QEMUDBGFLAGS = -no-shutdown -no-reboot + +GDB = gdb +ifneq ($(XDG_RUNTIME_DIR),) + # We should prefer using domain sockets in a private directory + GDBPORT ?= $(XDG_RUNTIME_DIR)/stubs-gdb.sock +else + # but fall back to PID + 1024, which should be an unprivileged unique port on single- and multiuser systems + GDBPORT ?= :$(shell echo $$(($$(id -u) + 1024))) +endif +ifneq ($(findstring /,$(GDBPORT)),) + QEMUGDB = -chardev socket,path=${GDBPORT},server=on,wait=off,id=gdb0 -gdb chardev:gdb0 +else + QEMUGDB = -gdb tcp:${GDBPORT} +endif +# (gdb itself supports either :port or a path as target) + +qemu: all + @echo "QEMU ${KERNEL}" + ${VERBOSE} $(QEMU) $(QEMUKERNEL) $(QEMUGDB) -display ${QEMUDISPLAY} -smp $(QEMUCPUS) $(QEMUFLAGS) ${QEMUEXTRAFLAGS} + +# Runs StuBS in Qemu with with hardware accelerations (KVM support) enabled +# The started emulator provides several virtual CPUs that execute in parallel. +kvm: all + @echo "KVM ${KERNEL}" + ${VERBOSE} ${QEMU} $(QEMUKERNEL) $(QEMUGDB) -display ${QEMUDISPLAY} -smp $(QEMUCPUS) $(QEMUFLAGS) ${QEMUEXTRAFLAGS} $(KVMFLAGS) + + +# Execute Qemu with activated GDB stub and directly connect GDB to the spawned Qemu. +gdb: all + ${VERBOSE} $(GDB) "$(DBGKERNEL)" \ + -ex "set arch $(DBGARCH)" \ + -ex "target remote | exec $(QEMU) -gdb stdio $(QEMUKERNEL) -smp $(QEMUCPUS) -S $(QEMUFLAGS) $(DBGFLAGS)" + +################################################################ +# Rekursive Targets: Setzen einzelner QEMU Parameter +################################################################ + +################################################################ +# Debugging mit GDB +# Sinnvoll anwendbar mit den Targets: qemu, kvm, *-curses, *-serial +%-gdb: + ${VERBOSE} ${MAKE} QEMUEXTRAFLAGS="${QEMUEXTRAFLAGS} -S" $* + +# um sich mit GDB auf dem Standardport zu verbinden +connect-gdb: + ${VERBOSE} gdb -ex "target remote ${GDBPORT}" $(DBGKERNEL) + +################################################################ +# Eine -display Variante erzwingen +%-curses: + ${VERBOSE} ${MAKE} QEMUDISPLAY="curses" QEMUSERIAL="vc:80Cx24C" $* + +%-x11: + ${VERBOSE} ${MAKE} QEMUDISPLAY=gtk $* + +################################################################ +# Serial-Ausgabe +QEMUSERIAL ?= vc:80Cx24C +QEMUFLAGS += -serial $(QEMUSERIAL) +%-serial: + @echo "HINT: C-a x: Terminate QEMU; C-a c: Open QEMU console" + ${VERBOSE} ${MAKE} QEMUSERIAL=mon:stdio $* + + +# Help for Qemu targets +help:: + @$(echo) "System Emulation\n" \ + " \e[3mqemu\e[0m Starts $(PROJECT) in QEMU\n" \ + " Due to the internal design of QEMU, some things (especially\n" \ + " race conditions) might behave different compared to hardware!\n\n" \ + " \e[3mkvm\e[0m Starts $(PROJECT) in KVM, a hardware-accelerated virtual machine\n\n" \ + " \e[3m*-serial\e[0m Redirect the serial console to stdout (e.g., qemu-serial, kvm-serial)\n\n" \ + " \e[3m*-curses\e[0m Use QEMU's curses interface (e.g., qemu-curses).\n"\ + " \e[3m*-x11\e[0m Use QEMU's GTK interface (e.g., qemu-x11).\n\n"\ + " \e[3m*-gdb\e[0m Start Simulator with internal GDB stub and wait for a GDB\n" \ + " to attach. (e.g., qemu-gdb)\n" \ + " \e[3mconnect-gdb\e[0m Connect to waiting GDB. Execute in a second terminal!\n\n"\ + + +# Phony targets +.PHONY: qemu kvm help diff --git a/tools/remote.mk b/tools/remote.mk new file mode 100644 index 0000000..326ac4c --- /dev/null +++ b/tools/remote.mk @@ -0,0 +1,39 @@ +# Test your system on real hardware + +NETBOOT_LOCAL="/ibr/adm/user-boot/" +NETBOOT_HOST="x1.ibr.cs.tu-bs.de" +NETBOOT_KERNEL="vmlinuz-$$user" +NETBOOT_INITRD="initrd-$$user.img" + +# The boot menu shows pairs of `vmlinuz-*` + `initrd-*.img` with owning user and timestamp. +# We just need to choose a name that doesn't overlap with another user's. +netboot: all + $(VERBOSE) \ + if [ ! "$$DEPLOY_LOCAL" ] && [ -e "${NETBOOT_LOCAL}" ] ; then DEPLOY_LOCAL=1 ; fi ; \ + if [ "$$DEPLOY_LOCAL" = 1 ] ; then \ + user=$$USER ; \ + else \ + user=$$( ssh -G ${NETBOOT_HOST} | grep -oPe '^user \K.*' ) ; \ + fi ; \ + \ + mkdir -p $(BUILDDIR)/netboot ; \ + ln -fT ${KERNEL} "$(BUILDDIR)/netboot/${NETBOOT_KERNEL}" ; \ + initrd="$(INITRD)" ; if [ -s "$$initrd" ] ; then \ + ln -fT $$initrd "$(BUILDDIR)/netboot/${NETBOOT_INITRD}" ; \ + else \ + echo "(none)" > "$(BUILDDIR)/netboot/${NETBOOT_INITRD}" ; \ + fi ; \ + \ + if [ "$$DEPLOY_LOCAL" = 1 ] ; then \ + echo "CP to locally as $$user" ; \ + cp "$(BUILDDIR)/netboot/${NETBOOT_KERNEL}" "$(BUILDDIR)/netboot/${NETBOOT_INITRD}" ${NETBOOT_LOCAL} ; \ + else \ + echo "SCP to ${NETBOOT_HOST} as $$user" ; \ + scp "$(BUILDDIR)/netboot/${NETBOOT_KERNEL}" "$(BUILDDIR)/netboot/${NETBOOT_INITRD}" ${NETBOOT_HOST}:${NETBOOT_LOCAL} ; \ + fi + +# Documentation +help:: + @$(echo) "Netboot\n" \ + " \e[3mnetboot\e[0m Copies $(PROJECT) to the network share, allowing the test infrastructure\n" \ + " to boot your system" diff --git a/user/Makefile b/user/Makefile new file mode 100644 index 0000000..ea3cb72 --- /dev/null +++ b/user/Makefile @@ -0,0 +1,20 @@ +# Default target +.DEFAULT_GOAL = all + +include ../tools/common.mk + +# assemble list of all apps +APPS = $(filter app%/, $(wildcard */)) + +IMGBUILDER = $(BUILDDIR)/imgbuilder + +# (Achtung: ist auch in ../Makefile definiert!) +INITRD = $(BUILDDIR)/initrd.img + +all: $(INITRD) + +# recipe for building the final oostubs image +$(INITRD): + @echo "IMGBUILD $@" + @mkdir -p $(@D) + @touch $@ diff --git a/utils/flake.lock b/utils/flake.lock new file mode 100644 index 0000000..735cf22 --- /dev/null +++ b/utils/flake.lock @@ -0,0 +1,43 @@ +{ + "nodes": { + "nixpkgs": { + "locked": { + "lastModified": 1740560979, + "narHash": "sha256-Vr3Qi346M+8CjedtbyUevIGDZW8LcA1fTG0ugPY/Hic=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "5135c59491985879812717f4c9fea69604e7f26f", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "nixpkgs": "nixpkgs", + "systems": "systems" + } + }, + "systems": { + "locked": { + "lastModified": 1680978846, + "narHash": "sha256-Gtqg8b/v49BFDpDetjclCYXm8mAnTrUzR0JnE2nv5aw=", + "owner": "nix-systems", + "repo": "x86_64-linux", + "rev": "2ecfcac5e15790ba6ce360ceccddb15ad16d08a8", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "x86_64-linux", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/utils/flake.nix b/utils/flake.nix new file mode 100644 index 0000000..c40f899 --- /dev/null +++ b/utils/flake.nix @@ -0,0 +1,64 @@ +/* + * This file allows you to run `nix develop` to get a shell with all external dependencies (`make` plus the tools it calls) of this repo (and maybe some beyond). + * The only thing required is an installation of the "Nix" package manager for Linux (/WSL) or MacOS: https://nixos.org/download/ +*/ +{ + description = '' + The educational operating system StuBS. + ''; + inputs = { + + # The rolling-release of the Nix(OS) package definitions. Use `nix flake lock` to update + nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; + + # Some boilerplate: + systems.url = "github:nix-systems/x86_64-linux"; # no cross compiling and only x86(_64) for now (darwin (MacOS) might work) + }; + outputs = + inputs: + let + lib = inputs.nixpkgs.lib; + eachSystem = + f: + lib.foldAttrs lib.mergeAttrs { } ( + map (s: lib.mapAttrs (_: v: { ${s} = v; }) (f s)) (import inputs.systems) + ); + in + { } + // (eachSystem ( + localSystem: + let + pkgs = import inputs.nixpkgs { system = localSystem; }; + in + { + + # The shell environment definition used by `nix develop`: + devShells.default = pkgs.mkShell.override { stdenv = pkgs.clangStdenv; } { + nativeBuildInputs = + with pkgs; + [ + # for all tasks and maintenance + gdb + qemu_kvm + nasm + ccache + unixtools.xxd + git + libisoburn # for building iso images + grub2 + python3 + bear # make compile_commands.json + clang-tools # for clangd and clang-format + ] + ++ (lib.filter ( + pkg: lib.isDerivation pkg && pkg.pname or "" != "glibc" + ) pkgs.stdenv.allowedRequisites); # basic tools + compilers (gcc/g++) + env = { + # This will tell the iso builder where the grub tools may be found + GRUBBIN="${pkgs.grub2}/lib/grub/i386-pc"; + }; + }; + + } + )); +}